Top Tweets for #MoldableDevelopment
You should certainly understand the inside of systems, but that understanding should not be attempted by either reading the code or by asking the AI for answers. Learn to rely on contextual deterministic tools instead.
Take a look at #MoldableDevelopment
If you’re not reading the code, whether explicitly or through agentic inquiry, one or more of these is true:
○ You’re a beginner
○ Software is throwaway
○ You’re prototyping
○ You have no users / revenue
○ You’re taking on debt & risk
○ Your problems are basic
And btw. All of this is fine. But the reality is that models are still not at the “full autonomy” stage yet.
They make rookie mistakes, they go down bad architectural paths. I just had the best model in the world add a nonsensical 700ms delay to “settle” something and it told me “you’re right, I was cargo-culting” 🤨
I am on the camp that this need will diminish more and more. Most code is indeed going to be assembly-like. But we also have the global internet and software infrastructure riding on these models and narrative, and we have to respect that.
https://t.co/wgxb7yBogN #ElixirLang #MyElixirStatus #SmallTalk #GToolkit #MoldableDevelopment @feenkcom
Original post: https://t.co/D62jcYmkmJ
Is anyone working on "lovable for private repo/product" style of tool?
I either build myself one or use something out there that can help non-tech stakeholders to do #moldabledevelopment on an app.
DM me if you want to join the waitlist
I often tend to talk about #MoldableDevelopment in too abstract terms. I did it in a call just now. It's not the most useful inclination. That's when I wish I had @swardley next to me to bring me down to earth and show concrete examples. Like he did in this chat when he had me show him how I construct a custom tool for exploring an API on the spot.
What do you think about this example?
I am talking quite a bit about making systems explainable through #MoldableDevelopment. This is a new way of programming and I am still searching for the effective compact narratives.
If you are interested to learn how it can apply your specific context (technology, domain, process), please ask questions either publicly or in a DM. I will answer them. I believe it will make the exercise more interesting for you and it will certainly be helpful for me as well. Win-win 😃.
So, what do you say? Care to comment?
#MoldableDevelopment is about programming through custom tools. Little tools, often in the shape of object views.
The key to making this practical is to decrease the cost of creating those custom views. While we already could create them in minutes, we've always been interested to get to costs measured in seconds.
Yes, yes, I know that #GenAI can be interesting in this context. But before we explore that path we should first try to exhaust possibilities that are much more approachable, explainable and ... less magic.
Like the approach described below. Once we accept that tools can be combined in a myriad of ways, we can get to all sorts of unexpected properties.
Let's look closer at the scenario from the video. We start with a file reference that points to an MP4 file. We see a view with the file path, but we'd rather also see a movie player. So, we write a script that produces an element that can play that movie in a web browser. Then we ask the object to give us a default view and Voilà!
This scenario is possible because we could combine the result of dynamic execution with the static extraction of a view and bring that magic in an interactive editor.
There is a tremendous potential for augmenting our human ability to relate to systems. And the key lies in the environment.
In our quest to make creating views more and more inexpensive, we now got to the point in which we can create custom views based on the object obtained from executing a snippet in the contextual playground from an inspector.
Sounds complicated? It's really not. Just take a look.
If you are a technical person and want to convince your business manager to invest in better skills and tools for legacy modernization, start from the business perspective.
Say you looked into #MoldableDevelopment and are now convinced that you need to invest in it because it's your way out of what feels like a legacy hell. But how do you convince your business manager to invest in it?
One way is to start from a problem that business can quantify. Investing in the skills and technology needed to create custom tools is not on any business person radar today. Furthermore, often programming itself is still perceived as just a cost rather than an investment. In such situations, it can be difficult to argue for more investment. But they do have problems that they want to see addressed. There are at least two kinds of such visible problems:
1) long standing problems that do not seem to be ever addressed, or
2) pressing problems that are (about to be) triggering crises.
In the long standing category could be decreasing the cost of bug fixes after a release. It can be speeding up the customer support. It can be accelerating the adaptations to external systems. It can be limiting the risks associated with a long running migration. It can be improving the performance or scalability. You get the idea. In this category you can take a sample of the problem and show how that can be improved. Most of the time these problems are due to lack of visibility. Build dedicated tools for them to get a better perspective. It inevitably leads to new insights that you can then act on.
A recognized pressing problem can be another point to start from. I say "recognized" because there are always problems but most are typically not acknowledged on the business side. When in a crisis with no visible way out, people tend to be more inclined to try last resort actions and accept apparent magic. You can use this as an opportunity. Create tools that provide insights that are directly relevant for the crisis and build from that.
All in all, instead of selling the custom tools idea, you can show outcome. Start from a quantified problem and deliver a quantified result. Once you've done that you can show how you've done it and argue for more investment.
Btw: this path does not require scale. It can start with a single programmer.
#MoldableDevelopment is a way of programming through custom tools. We approach every development problem through a custom tool built specifically for that problem. This often leads to thousands of little tools per system...
"Thousands of tools? But is this not expensive?"
Well, no. Quite the opposite. They are cheaper to build than not to build. These tools do away with most need to manually read code, and reading code is the most expensive activity in software engineering today. Instead, these custom tools, built specifically for the questions we have, summarize the system and help us make decisions much faster and more systematically.
"So, these tools summarize the system. What AI are you using to build them?"
Ahh, well, summarization is not the same as AI. For example, a view over some data summarizes that data. Such a view is produced by a small program that can be created to capture what we are specifically interested in at that moment in time. Through such views we can make decisions much faster than we can by reading the data directly. And everything in a system is data, including source code, configurations, logs etc.
While AI can play a role in this equation, it is not essential. We can indeed rely on some AI to generate tools but that is mostly an optimization.
"But tools are expensive. How can it be practical to build thousands of them?"
Well, that's the thing. Tools do not have to be expensive. They can be as inexpensive as a few lines of code built in minutes.
"It's hard to believe this."
I know it is. That is why we built Glamorous Toolkit. Take a look.
"Ah, so this is whole Moldable Development thing is just an ad gimmick for your commercial tool?"
Not really. Glamorous Toolkit is free and open-source. We built it exactly so people can experience the idea of custom tools by themselves, in their own terms. Moldable Development is a practice. We used and validated it extensively. You can use #GToolkit to solve actual engineering problems with your systems. At the same time, and perhaps more important, Glamorous Toolkit is an extensive case study of Moldable Development showcasing literally thousands extensions that explain the inner workings of the environment.
#GToolkit shows that #MoldableDevelopment can be practical. It comes both with abilities to create custom tools and, perhaps more importantly, it comes many examples of such concrete custom tools. Most prominent, of course, are extensions for and with Pharo code. But what about other technologies?
The talk below offers a compressed overview of several integrations that work out of the box.
@Chis_Andrei shows how we can work with snippets in other languages, such as Gemstone and Python, just like we can do with a local Pharo snippet. And we can combine them at will, too. This is already interesting, but the more important part is that the object inspector can be extended in the target language as well. For example, inspecting a Python object can show a dedicated view specified in Python and it feels as seamless as inspecting a local object.
We want to show that the cost of tools can be much lower than people might expect today. An important part of the perceived cost is the language in which the extension is expressed. By making it possible to express extensions in the language developers already know, we decrease significantly the cost of learning and experimenting with the new practices.
Andrei also demos how to write custom code rewrites for different languages, and then he casually explores what happens when the web browser is embeddable anywhere in the graphical stack.
Take a look and please let us know what you think.
#GToolkit can be integrated in many different ways with other systems or runtimes.
Watch @Chis_Andrei showing examples of such integrations.
https://t.co/gNgadlEFYi
Recently, we focused our attention on Moldable Debugging. Here is @Chis_Andrei giving a tour of what we mean by it.
https://t.co/ijzAdVacWv
#MoldableDevelopment with #GToolkit
Explaining #COBOL can be playful.
Here, we expand a reference to a screen in a to reveal the screen preview right in the editor of the COBOL source code.
#MoldableDevelopment
Going from a #COBOL screen to the flow of programs and screens it can lead to.
#MoldableDevelopment with #GToolkit
When looking at a system developed following #MoldableDevelopment, people's attention is attracted by the existing tools. But those are secondary. The most important part is the act of creating a new tool.
Take a look at the attached picture. It's a profiler tool that is targeted at the execution of a debugger.
- On the left you see the duration of rendering frames, red frames being those that took more than 16s (as we are targeting 60 frames per second).
- On the right, you get details of a single frame, one of which is a visualization of which parts requested a relayout and which requested a repaint.
This tool helped us improve the performance of our debugger with an order of magnitude. We actually had the performance issue for a long time, but it was only after we figured out what we wanted to see that helped us to materialize the tool that eventually made the problem apparent (the issue was the too eager update of the user interface).
Here is the thing: tools are built by someone. That's what matters. For your problems, there are no ready made tools. True, there are approximate tools, but not the tools you really care about. Only you know what those should be. And that's the magic. Learn to build your tools and reasoning about your systems will feel humane.
We help organizations solve their hardest problems:
We modernize legacy systems.
We use a mix of technology and business assessment, technology optimization, reverse engineering and migration.
Our not so secret ingredients?
#MoldableDevelopment combined with #WardleyMapping.
However, if your focus is on digital transformation then I'd suggest talking to @esynergy_ - https://t.co/RBEOI04ytv - they can drag me in when needed.
If your focus is on super hard problems like legacy then I'd suggest talking to @feenkcom - https://t.co/eHbSE4JaBQ
Custom inspectors in the wild.
#MoldableDevelopment
"you can't debug print shaders" oh yeah? well check this shit out
that's right, a whole ass view matrix, served directly from the GPU
AI can definitely help with creating tools. We have a project in which we are applying #MoldableDevelopment to that as well.
You asked what is the difference to the react app. The main difference is that what I am showing here is literally the same thing we are doing when we face any problem in any situation in any technology. It's nothing special.
On a more technical level, the react app is ... an app. It has a rigid frame. In my case, there basically is no tool. There are just some scripts, some objects and some views. And we concatenate them together live. The experience is not fixed. We choose it during analysis. And we can extend it seamlessly as well.
Whoa, just had an incredible moment with AI generating debug tools on the fly...
Was pair programming w/ @qualmist and we were struggling to interpret textual output from a CLI tool.
So we had Claude build us a visual debugger, and it totally crushed it 😎
quick backstory:
So we were playing around w/ synctex, a tool that maps locations in Latex files to locations in an output PDF.
Pretty simple, you can ask it "line 5 in the .tex file, where's that in the pdf" and it'll spit out a bunch of numbers representing coordinates for boxes in the PDF:
h:133.768372
v:275.285675
W:343.711060
H:9.065993
Hm, it's hard to *see* what those numbers actually mean on the pdf! we were doing coordinate math, manually measuring cursor positions... yuck. felt like we needed a more visual workflow.
Enter Claude! Asked it to make a React app that actually *draws* the boxes as overlays on top of the PDF.
You just paste in the CLI output and upload an image of the PDF. it parses the output and draws red boxes in the correct positions on the image.
This is so much faster than manually parsing the CLI output!! allowed us to quickly try some experiments and get a better feel for how synctex works in various cases.
Generating the tool took a few iterations and the AI wasn't perfect, but honestly it made very few mistakes and was totally good enough to keep us in flow of conversation. I was repeatedly impressed by 3.5 Sonnet getting things right that it feels like GPT-4 would have failed at a year ago, e.g. coordinate math stuff.
@simonw says "AI-enhanced development makes me more ambitious with my projects". This is exactly that philosophy at play. No way I would have tried to code this debugger manually during a pairing session. But AI lowered the cost enough to try it.
A strange reflection about this process: when you're building debugger tools with AI, there's a lot of leverage because there's 2 compounding layers of acceleration:
1) AI makes it faster to iterate on debug tools...
2) ...and debug tools make it faster to iterate on your project!
As a live programming nerd this idea gets me tremendously excited. Until now, it's generally been too expensive for devs to build bespoke visualization tools in the flow of coding their projects. But when that cost comes down, and it's faster to build custom tools, then it feels possible to accelerate work in a meaningful way.
So yeah, I guess I'd summarize the lesson here as: AI-enhanced development makes me more ambitious with my debuggers...
Last Seen Hashtags on Sotwe
gaypaintings
Seen from United States
ankaragay
Seen from Turkey
Corporeos
Seen from United States
gaypakistanis
Seen from United States
puffyanus
Seen from Switzerland
shemaleblowjob
Seen from Turkey
Narcoeatado
Seen from United States
teenageb() +filter:native_video()
Seen from United States
partner3s
Seen from Indonesia
cheatingexposed
Seen from France
Trends for you
Most Popular Users
Elon Musk 
@elonmusk
241.3M followers
Barack Obama
@barackobama
118.8M followers
Cristiano Ronaldo
@cristiano
114.5M followers
Donald J. Trump
@realdonaldtrump
111.9M followers
Narendra Modi
@narendramodi
107M followers
Rihanna
@rihanna
98.7M followers
NASA
@nasa
92.3M followers
Justin Bieber
@justinbieber
91.8M followers
KATY PERRY
@katyperry
90M followers
Taylor Swift
@taylorswift13
84M followers
Lady Gaga
@ladygaga
75.5M followers
Virat Kohli
@imvkohli
73.4M followers
Kim Kardashian
@kimkardashian
70.8M followers
YouTube
@youtube
68.7M followers
Neymar Jr
@neymarjr
66.4M followers
Bill Gates
@billgates
65.2M followers
Selena Gomez
@selenagomez
63.1M followers
The Ellen Show
@theellenshow
62.2M followers
CNN
@cnn
61.7M followers
X
@x
60.6M followers