@matthewskelton

#Complexity #SoftwareEngineering #JamesLewis #Programming #ProgrammingAnarchy #Tech #SoftwareDevelopment #SoftwareTechnology #SoftwareCycles #ProgrammingCycles #DesignPatterns #TeamTopologies #SoftwareArchitecture #Microservices #Scale #Thoughtworks #ScaleDown #SelfSimilarity #SelfOrganization #Emergence #CorporateMetabolism

Patterns for Building LLM-based Systems and Products #ai #llm #designpatterns https://www.luisquintanilla.me/feed/patterns-for-building-llm-systems-products-yan?utm_medium=feed

Because of reasons, I just remembered my first agency job. Since #JavaScript didn’t have inheritance, classical #OOP was considered the indispensable bat belt that contained the solution to every possible #programming problem. Because.

So the very senior #JS developer who started along with me introduced as the first user code dependency to our first project:

THE SIMPLETON PATTERN

Hey Siri, repeat 1e10 times: 😅 😂 😁

#Singleton #DesignPatterns

A simple method to continuously identify (and confirm) #api #designpatterns

Work together to discover when an actual use case can be abstracted into a common pattern.

The pattern starts with a 0.1 version upon deployment.
Graduate to 1.0, when three use cases adopt it.

After that, it evolves with minor and major versions based on backward compatibility.

Very excited to read up on this work by my former colleagues at ThoughtWorks - We need to start having conversations about the emerging patterns in LLM related application development: Building Boba AI https://martinfowler.com/articles/building-boba.html #generativeai #llms #copilot #designpatterns

I first read this article 15 years ago or something like that.

It was an age when fat books on #DesignPatterns ruled our industry, and the original 1994 Design Patterns book was seen as the Bible of software development that every aspiring senior needed to know inside out. It was an age when you couldn't be a senior developer if you weren't wrapping your logic into tons of factories, builders, adapters, façades, singletons, proxies, bridges etc., ensuring that any developer who read your code had to navigate through dozens of classes that did absolutely nothing before getting to a piece of actual business logic.

Building software in the early 2000s (especially in Java or C#) felt like wrapping a small kernel of business logic into an ever increasing number of boilerplate onion layers whose only purpose was to create abstractions that could make your application general-purpose/future-proof for whatever type of data you fed into it - even if the purpose of your application was very clear and you didn't have to do that, or, worse, if you were creating the wrong abstractions on the basis of a partial understanding of the problem.

This article captured this situation very well. You want to build a spice rack for your house, you know how to use nails and hammers, you go to a hardware shop, and the shopper tells you "we don't sell hammers anymore - we only sell blueprints for general-purpose tools factory factories, which can produce blueprints for hammer factories, which can produce actual hammer factories, which can produce your hammers".

Fast-forward a decade or so, I feel like the design patterns craze has largely subsided (although I can still see engineers who were forged/traumatized in those years abusing them). I mean, many of them have survived, but they are applied much more pragmatically - only when projects are large and general-purpose enough to require them.

I've used them extensively in Platypush, but it's only because it's an application that actually needs to model entities as an abstract concept, and an entity can be anything (a sensor, a camera, a video player, a lightbulb, a calendar...). Most of the software out there doesn't have to be so general-purpose, and therefore it doesn't need to go heavy on abstractions.

Also, the shift towards more functional patterns to complement object-oriented programming means that we aren't trying anymore to force all the possible concepts into objects - Java developers in the 2000s and 2010s were akin to those who had learned how to use a hammer and thought that the whole world was about nails. The concepts of composition and enrichment are much easier to model if you rely also on predicates rather than objects alone.

https://factoryfactoryfactory.net/

https://www.youtube.com/watch?v=tAuRQs_d9F8

8 #DesignPatterns Every Developer Should Know
* Factory
* Builder
* Singleton
* Observer
* Iterator
* Strategy
* Adapter
* Facade

11 / #100DaysOfCoding

170 days left to Christmas (91% completion rate of c.d.)

#ITByte: #DesignPatterns for #MachineLearning.

What are the common design patterns in developing and deploying Machine Learning solutions?

https://knowledgezone.co.in/posts/6321753eab0466cb66aa40ac

The official WordPress pattern library has a new toggle. Select "Curated" to view WordPress core design patterns. Select "Community" for design patterns contributed by the WordPress community at large. Enjoy! https://wordpress.org/patterns/ #WordPress #DesignPatterns

📣New in MEAP📣

Looking to take your Rustlang skills to the next level?

Go beyond the basics by studying design patterns & find tips and tricks that help speed up delivery and make full use of Rust’s lesser-known features: http://mng.bz/GymA

#rust #rustlang #crates #rustcrates #designpatterns

This month in Reckoner development, I learn about frontend #designpatterns and stop worrying and embrace #MVC !

https://velten.dev/blog/reckoner-update-2023-06/

Educate me:

If you are already using MVC then why use the Mediator pattern?

Both use 'routing'....

#designpatterns #mvc #dotnet #aspdotnet

Learn about the unique and unusual operation of "rolling binary trees" and implement an algorithm that performs it in linear time, using common design patterns and principles in #Java. #algorithms #binarytrees #bigo #designpatterns. By George Tanev on Foojay :foojay: Today.

https://foojay.io/today/rolling-binary-trees-a-guide-to-common-design-patterns-in-java/

#foojaytip

Looking for a better pattern.
There may not be one.

Previous dev designed a 'Rules Engine' set of tables.

Essentially, an app has to iterate through the entire Rules table and if the rule evaluate 'true' then you have a match.

But the rules are 'ranked' much like a search engine ranks results.

The top 1 is the rule that is the winner. But there can be many that come after it.

Currently there's a finite set of properties as input.

Why not just build a select instead?

#designpatterns

Learn about an uncommon & unexplored operation in the context of binary trees: roll (or rolling), which modifies binary tree structures.

https://foojay.io/today/rolling-binary-trees-a-guide-to-common-design-patterns-in-java/

#foojaytip #computerscience #research #datastructures #algorithms #binarytrees #bigoh #designpatterns #solidprinciples #cleancode

Me han pasado esta absolutamente maravillosa colección de patrones de diseño para #PHP, que vienen hasta con diagramas #UML, y no podía no compartirla https://designpatternsphp.readthedocs.io/en/latest/README.html #designpatterns

Recommend I follow someone!

Interests:

#dotnet #designpatterns

#guitars #jazz #musictheory

#oldcars #cadillacs

Thinking more about a 'Rules Engine' and/or the 'Specification' pattern.

'Search' engines rank results based on criteria. My use case would also rank them but not nearly as complicated as a search engine.

Mine has to do with financial.

Each "rule" is tied to a fund.

Pass all the criteria/components and you've got a winner.....unless that fund is out of money.

Then its on to the next rule & set of criteria.

#designpatterns #programming

"Remote calls are not services."

"If you have built a code generator, would you do it again?"

(NOPE)

".. SOA becames microservices..."

This talk resonates A LOT for me.

I'm not quite convinced I'd take his approach (vertical slices vs. layers) but its very intriguing.

#designpatterns #soa #microservices #udidahan #rulesengine

https://youtu.be/Fuac__g928E

A previous dev here at work developed what he called a 'Rules Engine' database solution.

The application ingests a csv file.

Essentially the "Rules" table is iterated and compared to values in the CSV.

The first "Rule" which passes, is the one that is applied.

Finally the values in the csv row and the result of the Rules Engine are stored in the DB.

From what I can tell, this is an implementation of the 'Specification Pattern'. But mostly in a DB.

#designpatterns #programming