My experience is 13 years of trying really hard to do the right thing within a sinking ship. Yes, we where young and inexperienced; and yes the foundation of the system was built using what turned out to be the worst turds in Delphi; and yes, I agree that it's possible to build better software in Delphi. But no, really; enough is enough; unless you're absolutely forced to, I see no advantages in choosing Delphi these days.
Tesla was brilliant, following your passion is the only way; sooner or later that penny has to drop for everyone. Who are we to judge utility from our limited perspective? What if the rules of the game were rigged from the start? What if chasing money is something we're supposed to transcend?
It always seemed weird to me to hire expensive specialists only to slap them around and override their experience by insisting on sub-optimal tools, methods and work environments. It took me 30 years of diligent, daily practice to get here. That experience better be put to good use or I'm out, I have no patience for business bullshit.
That early experience gradually got me motivated enough to learn more powerful tools. These days, Common Lisp (https://github.com/codr4life/cl4l) is my preferred tool for most problems; but I'm gradually learning to like Forth as an embedded DSL (https://github.com/codr4life/lifoo) and might be convinced to write C (https://github.com/codr4life/libc4life) under the right circumstances. I swore early on to never, ever settle for crumbles from the design table again. Then I kept on learning the same lesson over and over again through most languages in common use, until I finally accepted that nothing but simple, powerful, general purpose and free was going to work for me. Mysterious ways, indeed :)
I did professional development in Delphi for 13 years, writing and maintaining a sprawling 700k line reservation system. I don't miss it much. It was a great learning experience to have to fill in all the gaps in the standard libraries by twisting and turning Pascals rigid rules into something semi-useful; writing foreign function interfaces to WinSock to get around the limitations in the provided toy socket implementation; finding ways to convince the over-engineered pixie-dusty data-layer to issue effective SQL; and trying to keep up with Borland's, nay Inprise's, wait Embarcadero's, ever changing priorities and price hikes.
I don't even find the GUI-builder that amazing. It's very easy to use, and up to a certain scale it's very convenient; but it encourages and rewards coupling the implementation to the interface at every turn, making any attempt to do the right thing an uphill struggle.
One of the most painful memories I have from software, the stuff that haunts me in my dreams; is writing stored procedures for Delphi's favorite database, Interbase. Whenever you did something wrong, it would give you an error saying 'Error at BLR offset 283729' or similar, offset being the offset in the compiled code where the error supposedly happened; thereby forcing an inhuman level of discipline when making changes. I had to write and maintain thousands of lines of that bullshit; since by the time we dug that deep into the performance of the BDE, the entire application was fused to it on UI level. Switching meant going through every single stupid form in the application and carefully translating event logic, bindings and properties to pure SQL.
We should kill work, period. This is not the way it always was, and it's not the way it always will be. This is a brief moment in evolution, a learning experience. If some didn't insist on having plenty more than others, there would be enough for everyone without anyone working for anyone; and once you have everything provided, helping out is the natural thing to do.
Oh, there have been plenty of attempts to write down exactly what that is. The problem is that more than half of it will inevitably consist of bullshit ceremonies, bike-shedding and marketing. Given enough experience to cut the right corners and knowledge about actual use cases for the old software, rewriting is not the horror story that's currently on auto-repeat.
The part on perfectionism is also well worth repeating; pretending to be perfect, and/or bullying others into the same madness is a waste of energy and oxygen that could be better used to move forward.
"Perfectionism and fear of external judice insert a designing bias that will result in poor choices in order to refine a design only according to psychological or trivially measurable parameters, where things like robustness, simplicity, ability to deliver in time, are often never accounted for."
"When the task at hand is much more rigid, with specific guidelines about what tools to use and how to implement things, the ability of a 10x programmer to perform a lot of work in less time is weakened: it can still exploit “local” design possibilities to do a much better work, but cannot change in more profound ways the path used to reach the goal, that may include, possibly, even eliminating part of the specification completely from the project, so that the goal to be reached looks almost the same but the efforts to reach it are reduced by a big factor."
This is one of the reason working in software sucks so badly these days. You'll inevitably be forced to work with lesser tools in more ceremonial ways, which takes away most of the leverage from experience and skill; effectively dragging everyone down to the lowest common denominator where everything is done according to some stupid, over engineered specification.
And one of the beefs people seem to have when I share my code publicly. Cutting corners and side-stepping complexity is where coding turns to art for me, where the fun begins; which means that many of my programs look like toys in comparison to "serious" software. Yet they still manage to get the job done for less effort, and a closer look reveals that the simplicity is carefully engineered. I just don't have much time or patience for ceremonies these days.
"Hacking lives on, if you can stay out of Federal Prison, but people are ultimately more enamored with the big money. The tech press, especially. Chasing dollars and begging millionaire 20-somethings? Networking, even? Not exactly what I like to call, the Hacker way."
The Hacker way, a lost art indeed; Linus, you rock!
Feel free to define whatever however you want. This is a virtual DOM, because that is what the expression means; who's most popular right now matters not at all. And the only reason you feel obliged to drag the discussion down to this level is because it makes you feel insecure. You would do well to learn to like that feeling instead, that leads forward.
It's one step up from Excel, and more rope to hang yourself in; but it's not like it's going to replace the kind of work that any serious developer would miss. It never will; systematic, abstract thinking will always take practice and some amount of predisposition. And interacting with computers all day is not really the party that non-developers seem to think, it's not primarily about syntax and interface; many can't deal with the frustration and uncertainty.
Trust me, I'm more amused at the level of ego scrambling than upset about anything. My goal is to make sure the ideas reach out through the noise of ignorance; and they are, despite all the huffing and puffing in this thread.
When did React become the definition of anything? Why not Seaside? They came up with the idea around 15 years before React entered the scene. This is pure stupid, straight through. It's a DOM and it's virtual, hence a virtual DOM.
Nothing could be further from the truth, my only beef is that nothing of substance has been said; anyone with eyes to see would tell you the same. The fact that you feel the need to push the useless bullshit further tells a story of sore toes and little else.
And from another, more constructive perspective it's the beginnings of a modular, extensible virtual DOM implementation in perfectly acceptable Common Lisp with transaction support. Is this the way you look at the world in general, with -10 negative bias? Or did I hurt you ego somehow?
Keep on downvoting, friends; as long as it makes you feel better :)
Look, I'm sorry if I stepped on any ego toes; but I truly think most of the current practice is a mess of bad ideas and duct tape, and I have plenty of experience to back that up. Disagreeing is one thing, shooting messengers at any cost is counter-productive. I'm sharing ideas, you're arguing definitions.
Which part of 'this is a foundation on which change-tracking and callbacks will be added as opt-in features' didn't you understand? It's a DOM and it's virtual, hence a virtual DOM.
What would be the point of implementing the same thing the same way that has already been done a thousand times by others? It's a DOM, and it's virtual; hence a virtual DOM, period. Like I mentioned in the post, this is a foundation on which change-tracking and callbacks will be added as opt-in features.
We'll see when I get to the change-tracking part, last time I checked out parenscript it still didn't rub off on me. I would strongly recommend generating straight HTML for the initial layout though, I have really bad experiences from debugging completely dynamic pages in the browser. Additionally, one of the aims of this library is to generate any kind of HML in a reasonably effective way, whether static or dynamic.
Still, a virtual DOM is exactly what it is; a template engine would just dump the strings without offering support for modifying the document.
Well, the web browser only understands strings so sooner or later that will have to happen. But before and in-between generating strings you're free to update the DOM, which is the the exact purpose of keeping it around. And like I mentioned in the post, this is a general purpose foundation on top of which change tracking will be added as an opt-in feature.
The problem is that it's impossible to get an idea of someone's problem solving skills by feeding them artificial bullshit to solve. I strongly prefer the approach of having applicants show and discuss real code that they wrote themselves. And I'd consider not having any code to show a serious warning sign.
Facebook doesn't keep anyone connected to anything but their stupid algorithms and hidden agendas, the only thing you can be sure of is that nothing is what it seems to be and that they're doing everything in their power to twist your brain and sell your integrity.
Agreed, the stupid quiz culture is getting old. I suspect people who cling to this tradition wouldn't be able to code their way out of a paper bag outside the sphere of well defined problems with canned solutions.
I spent 13 years doing Object Pascal full time and wrote plenty of Modula-3 in school. From my perspective, everything from Wirth suffers from having too much syntax and focus on perfect abstractions, while not providing enough rope when "perfect" isn't perfect enough. I have similar experiences from Eiffel, it's all fine as long as you're solving the kinds of problems that the authors had in mind. Everything that can be done in these languages can be done in more pragmatic languages like C/++/Lisp; and as an added bonus, they don't pretend to know everything about the problem you're solving.
I generally try to stay as far away from mocking and stubbing as possible, and I have the scars to back that up from wasting countless hours on restructuring over-engineered tests to deal with minor implementation changes. Integration testing is where the rubber meets the road, which means more information for less effort.