#Software-Engineering
111 notas · última:
How to Make Software Engineers Do the 'Right Thing'
The text proposes priorities for creating a culture of responsibility in engineering teams: logging bugs, doing blameless RCAs, keeping CI green, monitoring logs, and reinforcing continuous improvement.
Clean Code: The Good, the Bad and the Ugly
The article praises Clean Code for naming, readability and code-smell awareness, but criticizes its outdated Java focus, dogmatic advice and verbose examples, especially the prime generator.
Software Engineering Talent is Gold Right Now
The job market is weak, but experienced software engineers can automate tedious or semi-manual workflows, create marketing assets, and get high leverage from tools like ChatGPT and Cursor.
Challenges in writing a programming book
The author describes the work of writing a software book, the time and money costs, and observes that developers tend to skim, prefer clear structure, and value video.
The Power of Lifelong Learning in Tech
The text argues that continuous learning is necessary for software engineers to keep up with fast-changing tools, meet industry demands, improve problem solving, grow careers, avoid burnout, and mentor others.
Beginner’s Guide to Freelancing
The guide says freelancing can bring experience, extra money, better communication and new ideas, but it depends on finding clients, negotiating well, handling legal basics and planning projects.
What Makes A Senior Software Engineer
The text argues that the jump from junior to senior lies in moving from building on what already exists to creating the foundation others will use. A senior engineer multiplies their own work by designing technologies and architectures that enable others to write better code.
Clean Code Essentials: YAGNI, KISS, DRY
The article explains YAGNI, KISS, and DRY as core software principles for avoiding unnecessary features, keeping solutions simple, and reducing repeated code.
Git Commands for Software Engineers
A guide to common Git commands for configuring repositories, tracking changes, managing branches, working with remotes, and handling history, stashes, tags, and patches.
Frank - How are you so productive?
The post frames productivity as maximizing value while balancing effectiveness and efficiency, then presents practical habits like prioritization, Kaizen, time boxing, focus, and escalation.
Don't Ask Anyone To "Be Your Mentor"—Do This Instead
The post argues that mentorship grows from genuine questions, interest in the other person, mutual help, and follow-up on advice. It also says books can function as mentors.
Goodhart's Law in Software Engineering
The text defends the strong version of Goodhart's law: when a metric becomes a target, it starts to drift away from the value it was meant to represent. In engineering, this appears in test coverage, complexity, benchmarks, and productivity metrics.
Flow state: Why fragmented thinking is worse than any interruption
Nick Moore surveys flow-state research and argues developer productivity suffers more from internal fragmentation (self-interruption, rote mundane tasks) than from external interruptions like Slack pings.
Software engineering job openings hit five-year low?
Gergely Orosz uses Indeed data to show software developer job postings down 35% since January 2020, worse than any other tracked industry, and works through zero-interest-rate policy, Section 174, and AI as candidate causes.
From Software Developer to Software Engineer
Gergely Orosz collects two takes (Ian Brayshaw, Hartley Brody) on what separates a software engineer from a developer, landing on iteration and understanding-why as the path between the two.
Picking Your Tech Stack For Dummies (and the future)
The post gives rules of thumb for early startup stack choices: use what you know when very early, prefer popular and supported technologies, stay mostly boring, but keep enough novelty to recruit and replace tech intentionally over time.
AI Is Forcing Us To Write Good Code
A six-person team enforces 100% code coverage, thoughtful file naming, and fast disposable dev environments because coding agents need the guardrails humans used to skip under deadline pressure.
Becoming a Professional Software Developer: Identity Over Skills
Applies James Clear's identity-based habits framework to software development: developers abandon best practices under deadline pressure not from lack of skill, but because the practice isn't tied to their self-image.
Don't Waste Your Back Pressure
Argues that agent leverage scales with the automated feedback ('back pressure') around them, like build systems, type checkers, and browser tools, not with the model alone.
Software Engineering Splits in Three
AI collapses the cost of writing code and shifts the bottleneck to judgment, splitting software engineering into three tiers with different platforms, skills, and consulting models.
7 Signs You're Underperforming as an Engineer
Seven behavioral warning signs of underperformance for software engineers, from sitting on blockers to skipping code review, paired with concrete actions for each.
The Next Two Years of Software Engineering
Addy Osmani lays out five open questions on how AI reshapes software engineering through 2026: junior hiring, core skills, the developer role, specialization, and education.
AI Writes Code Faster. Your Job Is Still to Prove It Works.
Osmani's framework for code review after AI: solo devs lean on tests as a safety net, teams need a PR Contract stating intent, proof, risk, and where to focus review.
We Need to Talk About Technical Debt
Argues technical debt and bad code are not the same thing: debt is a deliberate, repayable trade-off, bad code is a skills gap. Unpaid debt compounds into a rewrite.
Hiring and the market for lemons
Dan Luu tests Joel Spolsky's claim that great developers never hit the job market against Akerlof's market-for-lemons model, and finds most hiring complaints trace back to a few fixable causes.
Fragments: February 13
Martin Fowler collects notes from a Thoughtworks retreat: senior developers staying relevant with LLMs, cognitive debt outpacing technical debt, and the drift toward supervisory programming.
A Series of Vignettes From My Childhood and Early Career
Jason Scheirer strings together six anecdotes, from a 1996 warning that coding was ending to automating a coworker's job, as a rebuttal to every cycle of tech doomsaying he has lived through.
Should Junior Developers Still Learn JavaScript the Hard Way?
Argues junior developers should still learn JavaScript fundamentals — closures, scope, the event loop — before frameworks, blaming boring teaching, not the material, for why it feels pointless.
The Slow and Quiet Cognitive Atrophy of a Modern Software Engineer
AI-generated code looks clean and its own tests pass, but skipping the review step quietly erodes an engineer's own skill. Elmar Chavez traces the decay and argues discipline is what keeps understanding intact.
12 Hard Truths About Coding I Learned the Hard Way After 10+ Years
Twelve lessons from a decade of coding: estimates are guesses, seniority means more meetings, and almost every failed project traces back to a communication problem.
Visitor Pattern
Represent an operation to be performed on elements of an object structure without changing the classes.
Strategy Pattern
Define a family of algorithms, encapsulate each one, and make them interchangeable at runtime.
Proxy Pattern
Provide a surrogate or placeholder for another object to control access to it.
Prototype Pattern
Create new objects by cloning an existing instance.
Memento Pattern
Capture an object's internal state so it can be restored later without violating encapsulation.
Mediator Pattern
Define an object that encapsulates how a set of objects interact, promoting loose coupling.
Iterator Pattern
Access elements of a collection sequentially without exposing its underlying representation.
Facade Pattern
Provide a simplified interface to a complex subsystem.
Decorator Pattern
Attach additional responsibilities to an object dynamically, as an alternative to subclassing.
Chain of Responsibility Pattern
Pass a request along a chain of handlers until one processes it.