In my situation when parsing lines of code Twine stores the file path and concats the line number and column when getting the location within a file. It does this a lot so using Twine there really helps. The rope data structure can be used in a number of ways.
I’ve spent the past few months translating a C library heavy in pointer arithmetic to TypeScript. Concessions have to be made here and there but ended up making utility classes to capture some of the functionality. Structs can be represented as types since they are able to also to be expressed as unions similar to structs. These const types can have fields updated in place and inherit properties from other variables similar to passing by reference which JS can do (pass by sharing) or use a deep clone to copy. As far as affecting the underlying bytes as a type I’ve come up with something I call byte type reflection which is a union type which does self-inference on the object properties in order to flatten itself into a bytearray so that the usual object indexing and length properties automatically only apply to the byte array as it has been expressed (the underlying object remains as well). C automatically does this so there is some overhead for this that cannot be removed. Pointer arithmetic can be applied with an iterator class which keeps track of the underlying data object but sadly does count as another copy. Array splicing can substitute creating a view of a pointer array which is not optimal but there are some Kotlin-esque utilities that create array views which can be used. Surprisingly, the floating point values which I expected to be way off and can only express as a number type are close enough. I use Deno FFI so plenty of room to go back to unmanaged code for optimizations and WASM can be tapped into easily. For me those values are what is important and it does the job adequately. The code is also way more resilient to runtime errors as opposed to the C library which has a tendency to just blow up. TLDR; Don’t let it stop you until you try because you might just be surprised at how it turns out. If the function calls of a library are only 2-3 levels deep how much “performance” are you really gaining by keeping it that way? Marshalling code is the usual answer and Deno FFI does an amazing job at that.
Formal verification uses Prolog a lot. System on TPTP at U of Miami utilizes this for many of the formally verified tests on there. It is just a more intense discipline than general programming which is why I’m perpetually drawn to it trying to find more real world applications. It is not exactly Prolog but close enough to mention the similarities.
Well sure, but the hardware encode and decode isn’t completely widespread yet. I’ve been patiently waiting for what has felt like an eternity. From the developer perspective everyone needs to have access to it or I’m just sitting on my hands waiting for the capabilities to trickle down to the majority of users. Hopefully more users will purchase hardware if it features AV1 encode/decode. They need a logo that says “AV1 inside” or something. So, for example only the iPhone 15 pro offers hardware decode so far in the iPhone lineup.
The part of Root I use is Cling the C++ interpreter along with Xeus in a Jupyter notebook. I decided one night to test the fastest n-body from benchmarkgames comparing Xeus and Python 3. With Xeus I get 15.58 seconds and running the fastest Python code with Python3 kernel, both on binder using the same instance, I get 5 minutes. Output is exactly the same for both runs. Even with an overhead tax for running dynamic C++ at ~300% for this program Cling is very quick. SIMD and vectorization were not used just purely the code from benchmarkgames. I use Cling primarily as a quick stand-in JIT for languages that compile to C++.
Well then there is Emacs which is like an entire ripscrip BBS in your terminal if you configure it that way. If the Lisp you hand edit to actually make the plugin start up works you may want to also see what it’s doing apparently. Even though that happens sometimes Emacs is very good at what it does.
MFC also has CComPtrBase which uses & to represent pointer lifetimes to COM objects such as while(pEnum->Next(1, &pFilter, &cFetched) == S_OK). Especially fun when debugging DirectShow filtergraphs someone made in the UI completely. There is more of an explanation here: https://devblogs.microsoft.com/oldnewthing/20221010-00/?p=10...
I built one for the government keeping track of licensed professionals and receiving their payments for things reported in the field (mobile first web app). It collected over a quarter million dollars in 30-40 dollar payments with different tiers, refunds, overrides, and even penalties for non-payment all while being PCI compliant. One thing that helped a lot- create an auth system that lets the admin impersonate the customer to walk them through it. It’s a tough paradigm to start with but pays off immensely. Another was generating excel files and reports on demand from any view of the data in the app. One of the developers on the project implemented a simple state machine for payment histories and stored it in a number of tables with FK constraints. Do not do this! That means in the future your app will need to deserialize every customer’s history and after a few years the app will grind to a halt. This was the one issue with the app looking back. A state machine looks like a good fit for billing but if my future self could go back in time and warn everyone it would be with this one common problem or I wouldn’t even make this comment in the first place. If you do consider using a state machine just create thousands of customers with long detailed histories up front and if you can load them all up quickly then that is a good sign. Your billing system will only perform as well as you can transform and index data from customer history in bulk.
My own humble opinion is that Intel has always suffered from market cannibalization. They are a brand I look for but many times the iteration of products will force me to go a generation or two older because I can’t argue with the price and features. By the time I was sold on a NUC they were discontinued. I wanted a discrete GPU when they announced Xe but it has become Xe ARC alchemist, battlemage, celestial, and druid. By the time I’m ready to spend some money it will become something else usually. Also, they should have snapped up Nuvia. I’m still rooting for them but really if they could streamline their products and be willing to take a leap of faith on others in the same space it would help out a lot.
Was really looking forward to the j-core project and got into SH4 emulating the Dreamcast port of NetBSD which is currently available for the latest version which is 9.3 I believe.
There are also lots of interesting things going on with NAOMI emulation on the gaming side. All of it is very hackable and j-core would have made a great addition to that.
The time you spend on projects is, according to what the PM tells sales, two weeks for a feature and three weeks for bare minimum requirements new product. Outside of that your own company will guilt you into some feeling of inverse wage theft where you make up for it by donating your free time. Realistically, three months to build an app you can demo is tight but those are competitive timelines and you want to be competitive don’t you? AI I’m sure has skewed this towards less effort to meet those timelines (I hope). Another hard to swallow truth is that sometimes you are just given a project there is no optimal solution for because you were meant to fail at it. Usually it’s a problem client or impossible task. The more skilled you are the more likely it gets assigned to you. Developers that get to cherry-pick all of their assignments are also the ones that get to lie about their time allocations on projects (to add insult to injury). If you are a new hire you will be doing a lot of their work for them so climbing up the ladder takes a lot of humility. Most devs super concerned about other people’s mistakes usually cause a ton of problems themselves and this concern is directly related to all the things they are actually hiding/covering up in reality. It’s not uncommon to find that the Super Saiyan coder is actually keeping a proverbial building from falling down with a toothpick but they are very concerned about the formatting of everybody’s code. Younger developers think, by default, everything is crap but they don’t even bother to hide any of their screwups and they have the energy to keep screwing up for a long time and at an accelerated pace. This, ironically, does mean more money for the company so hiring a lot of young developers is good for the bottom line and makes customers seem very engaged.
Intelligence is cultural and I think many people don’t realize that. If I were to be dropped off in a random place on Earth I would encounter people, most likely, I wouldn’t be able to communicate with and even if they did understand me based upon who they are I may seem very stupid. In the wilderness I don’t have a lot of real survival skills and if someone discovered what I was doing to survive I may come off as very stupid in that context as well. Lots of examples and scenarios for this. For myself I have to consider things like just because someone hasn’t read history or literature and doesn’t understand the references I’m making does that make them stupid? Does their culture even concern itself with these things? Who am I to judge ultimately what makes someone stupid or not?
Well as much as I can understand the author of this article wanting to get past Riesman’s ideas in “The Lonely Crowd” the time period his predictions occur is during the age of “incipient decline” which is definitely right now and hasn’t ended yet. I do think Riesman predicted the rise of social media in the context of other-directedness without directly describing social media itself. Riesman’s work is still relevant but sure- it’s time for new voices to be heard.
Well, optimizing similar to how Rust guides the developer to write more optimized code. Comparing them is comparing apples to oranges however. There are many ways to get there. With Z3 you can do symbolic testing and it’s very much about defining if the expected output of the constructed IR is the same as the real output. When it comes to the IR I like to think of Z3 as almost an abstract assembler. Usually a separate language altogether is assembled via the IR that’s produced based on the rules given to SMT. LLVM optimization occurs after it’s been “assembled” but it’s the rules in place given to SMT which guides the developer to write code which can be optimized better by LLVM. Otherwise you could just write anything and hope that LLVM optimizes it. Personally, I wouldn’t want an extra application that tries to silently fix things beyond what LLVM does with IR because it would feel compulsory for everything. There should be an end goal for what it’s optimizing and why in the form of a proof or lemma for it to make sense in the context of Z3. So yes, definitely possible but probably more useful if you are building a new compiler for a new platform rather than trying to do better than an existing one.
For me between 2000-2005 F1 was fun to watch though after 2005 there were too many regulations and all the cars were too similar. If you want to see some overtaking and drama those were some great races.
One of the things I find refreshing about Gemini is there is no standard scripting language in there and the implementations vary wildly on the client side from Rust to Lua to Python to Go as well as the server-side. It made me realize perhaps browser technology for the Web got locked into specific domain-centric technologies which have held it back. There is so much C/C++ required for JavascriptCore and friends in a modern browser there is only one real choice to code in. Mozilla has made great advancements with Rust in Firefox but still a long ways off from a total conversion. It's not that its not possible but if you want to tap into the work which has already been done in JavascriptCore or other technologies you certainly cannot just pick your own backend or language. Gemini's efforts on the other hand are being brought up in parallel and in the open so that is a major strength that the ecosystem is already much more broad from the beginning. Building a modern browser from source nowadays is an intensive process on a single mid-range workstation just due to the fact much of the extra functionality is compulsory and not opt-in. Many of these modules were meant to be pluggable but somewhere along the way they became coupled dependencies of each other. A good example is Electron where in theory it should be just the things you need and a subset of a browser where applicable but instead you need the whole browser engine every single time.