#Software-Engineering
111 notas · última:
Adapter Pattern
Convert the interface of a class into another interface clients expect.
IC vs Management: A Longer Career Than You Think
The IC-vs-management decision feels permanent when you think in 10-year terms — but in a 30-40 year career, it's far less binary than it appears.
Multiplying Value Through Systems Thinking
Successful engineers multiply value rather than just adding it — think in terms of system effects, not just the immediate task, and the returns compound.
OTP (Open Telecom Platform)
OTP is a collection of middleware, libraries, and design principles for building applications in Erlang. The name stands for Open Telecom Platform — a branding attempt from Ericsson — but neither…
Gang of Four Design Patterns
The 23 design patterns catalogued by Gamma, Helm, Johnson and Vlissides in Design Patterns: Elements of Reusable Object-Oriented Software (1994).
Functional Programming
Functional programming is a paradigm where programs are constructed by applying and composing functions. It is declarative: function definitions are expressions that map values to other values,…
Prototype-Based Programming
In prototype-based programming there are no classes. Objects inherit directly from other objects through a prototype link.
CQRS
CQRS — Command Query Responsibility Segregation — is a pattern first described by Greg Young. At its heart is the notion that you can use a different model to update information than the model you…
Four Rules of Simple Design
Kent Beck formulated four rules of simple design while developing Extreme Programming in the late 1990s. A design is simple, in priority order, when it:
SOLID Principles
Five object-oriented design principles introduced by Robert C. Martin (2003); the acronym was coined by Michael Feathers around 2004.
Law of Demeter
"Only talk to your immediate friends; don't talk to strangers."
LLM predictions for 2026, shared with Oxide and Friends
Simon Willison shares predictions about coding agents, sandboxing, security, a browser built with AI help, and code typing fading as software work shifts away from manual syntax entry.
Interviewing for ML/AI Engineers
The essay argues that ML engineer interviews should mix coding, data modeling, system design, project deep dives, and career chats, while limiting ML system design interviews because they often produce low signal.
How I use AI (Oct 2025) - Ben Stolovitz
Ben Stolovitz describes where AI helps him most: coding autocomplete, research for “pub facts,” summaries, transcription, and editing. He is skeptical of AI search, writing, and image generation.
The price of mandatory code reviews
The post argues that code reviews slow teams down but reduce bugs, and that the best teams balance speed, review quality, and fast turnaround instead of reviewing every PR the same way.
Unlocking high software engineering pace: Build less, ship frequently, learn faster – Jim Grey on software management
The article argues that teams should ship the smallest useful version early, get real-user feedback, and learn faster instead of spending many sprints building a full feature before anyone can use it.
The Unwritten Rules to Becoming a Senior Developer: 4 Steps to Level Up
The article argues that senior growth comes from solid coding, team-oriented thinking, handling fires, and writing more to share knowledge. Titles matter, but promotion timing and career value are not the same thing.
The Best Programmers I Know
Matthias Endler argues that strong programmers read references, understand tools deeply, read errors carefully, break down hard problems, keep learning, and stay humble, patient, and simple in their work.
6 Characteristics of Successful Senior Engineers
The page lists six habits it associates with successful senior engineers: understanding scope, prioritizing work, documenting decisions, collaborating across functions, asking questions, and maintaining a growth mindset.
Advice for Less Experienced Software Engineers in the Current Tech Market
The article says the market is especially hard for entry-level software engineers and recommends widening applications, joining support groups, building experience, and taking the first offer that comes.
How to communicate as a software engineer
The article argues that clear workplace communication is mostly about brevity, structure, and empathy: use bullets, edit before sending, leave out minutiae, and put the most important information first.
3 tribes of programming
The essay argues that programmers tend to value one of three things most: programming as mathematical expression, as hardware-aware engineering, or as a way to build useful products for people.
How to Write Less Code for More Money
The post argues that mid-career developers can find better pay and less routine coding in QA, DevOps, specialized consulting, people management, or hybrid roles that mix support, teaching, and refactoring.
Software Engineering - The Soft Parts
Addy Osmani reflects on 10 years at Google Chrome and argues that engineering growth depends on fundamentals, communication, judgment, mentoring, trust, and managing time, scope, and technical debt.
Software Engineering Principles
The post introduces core software engineering and OOP ideas, then ties them to SOLID, composition, DRY, KISS, YAGNI, and UML-based modeling for cleaner, more maintainable code.
10 Books Every Senior Engineer Should Read
Semaphore lists ten books that shaped its engineering culture, covering agile practice, delivery pipelines, remote work, project management, data systems, SRE, microservices, and modern software engineering.
One Commit. One Change.
The post argues that commits should be atomic: one change only, so they can be reverted cleanly, keep builds consistent, and make history easier to trace.
10x engineer: 10% of the time
The post argues that perceived productivity in software engineering comes from a few practiced habits: debugging well, staying unblocked, choosing between manual work and tools, and reading code effectively.
The Tech Industry’s Darkest Secret: It’s All About Age
The post argues that tech careers favor youth, since older programmers face lower demand and weaker salary growth. It advises workers to move into management, entrepreneurship, or keep skills current.
Seven Habits of Highly Effective Programmers
The essay argues that effective programmers ship early, release often, use real data and builds, merge regularly, understand their code, manage their own work, keep learning, and earn respect through clear, responsible communication.
Signs that you're a good programmer
The page lists traits of good programmers, from experimentation and detachment from code to teaching, platform fluency, curiosity, and building tools. It also contrasts them with traits that can push people beyond ordinary programming.