Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
awesome-software-engineer-topics
A list of useful articles and videos generated from my Instapaper archived list on Software Design, Testing, Public Speaking, etc.
https://github.com/voxsim/awesome-software-engineer-topics
- Double Dream Hands: So Intense!
- How Are Method Calls Formed?
- I am a puts debuggerer
- Inside Ruby's VM: The TMI Edition
- OMG Ruby and Rails Performance
- RailsConf 2013 - Closing Keynote
- RailsConf 2014 - Closing Keynote
- RailsConf 2015 - Keynote
- RailsConf 2016 - Opening Day 3 Keynote
- Request and Response
- Taking Out The Trash
- Yak Shaving is Best Shaving
- The Evolution of Microservices
- A Conversation with him - ACM Queue
- Power of Simplicity
- Rethinking CS Education
- The computer revolution hasnt happened yet
- Hexagonal architecture
- How I saved Agile and the Rest of the World
- What is a process good for
- Why Agile Works
- NoEstimates
- The death of Agile
- Naming is a Process, part 1: Good naming is a process, not a single step
- Naming is a Process, part 2: Missing to Nonsense
- Naming is a Process, part 3: Nonsense to Honest
- Naming is a Process, part 4: Honest to Honest and Complete
- Naming is a Process, part 5: Honest and Complete to Does the Right Thing
- Naming is a Process, part 6: Does the Right Thing to Intent
- Naming is a Process, part 7: Intent to Domain Abstraction
- New code is legacy code
- The Core 6 Refactorings
- WET: When DRY Doesn’t Apply
- We are not fucking competent
- KPNs as an Effects Model
- Local State is Poison
- Out of the Tarpit
- Reactive State Transition
- Why Not Events
- Acyclic Dependencies Principle
- Code Smell
- Common Closure Principle
- Common Reuse Principle
- Coupling And Cohesion
- Dependency Inversion Principle
- Encapsulation Is Not Information Hiding
- Expression Problem
- Interface Segregation Principle
- Law Of Demeter
- Liskov Substitution Principle
- Make It Work Make It Right Make It Fast
- Open Closed Principle
- Reuse Release Equivalence Principle
- Single Responsibility Principle
- Stable Abstractions Principle
- Stable Dependencies Principle
- Test Driven Development
- Unix Way
- Datatypes: deftype, defrecord and reify
- Multimethods and Hierarchies
- Protocols
- Rationale
- Runtime Polymorphism
- Values and Change: Clojure’s approach to Identity and State
- Design Patterns And The Proper Cultivation Thereof
- Fun with Lambdas!
- Lambdas and a List of Cats: Test-Driving Lambdas
- Rules of Simple Design
- Some thoughts on pair-programming styles
- Live React: Hot Reloading with Time Travel
- The Redux Journey
- Agile is Dead
- How to be a concert pianist - Learning versus doing
- A peek inside Elixir’s Parallel Compiler
- Design Goals
- CRC Cards
- Refactor Mercilessly
- XP and the Mark IV Coffee Maker
- Create your own framework... on top of the Symfony2 Components Part 01
- Create your own framework... on top of the Symfony2 Components Part 02
- Create your own framework... on top of the Symfony2 Components Part 03
- Create your own framework... on top of the Symfony2 Components Part 04
- Create your own framework... on top of the Symfony2 Components Part 05
- Create your own framework... on top of the Symfony2 Components Part 06
- Create your own framework... on top of the Symfony2 Components Part 07
- Create your own framework... on top of the Symfony2 Components Part 08
- Create your own framework... on top of the Symfony2 Components Part 09
- Create your own framework... on top of the Symfony2 Components Part 10
- Create your own framework... on top of the Symfony2 Components Part 11
- Create your own framework... on top of the Symfony2 Components Part 12
- Hacker Way: Rethinking Web App Development at Facebook
- Smaller and faster data compression with Zstandard
- Continuous budgeting
- Remote working per un imprenditore, istruzioni all'uso
- La professione dello sviluppatore
- La professione dello sviluppatore (3 anni dopo)
- Boundaries
- Deconstructing the framework
- Fast Test, Slow Test
- Test Isolation Is About Avoiding Mocks
- The Birth And Death of Javascript
- Useing You're Type's Good
- Wat
- Five essential phone screen questions
- Flaky Tests at Google and How We Mitigate Them
- Get that job at Google
- Hackable Projects
- Just Say No to More End-to-End Tests
- CQRS and Event Sourcing
- Keynote: 8 Lines of Code
- Growing a Language
- How to Think about Parallel Programming: Not!
- Part 1
- Part 2
- Part 3
- Part 4
- Part 5 & 6
- 10 Ways to Kill Your Design
- 7 minutes, 26 seconds
- A Model for Improving Names
- A Real-Life Contract Test
- Beyond Mock Objects
- Clearing Up the Integrated Tests Scam
- Injecting dependencies doesn't have to hurt
- Integrated Tests Are A Scam
- Primitive Obsession Obsession
- Surely the Mars rover needed integrated tests! (Maybe not?)
- Tests Don't Have Special Permission To Repeat Themselves
- The Four Elements of Simple Design
- The Next Decade on Vimeo
- What your tests don't need to know will hurt you
- Extreme Contracts
- Extreme Contracts - Teoria dei vincoli e contratti
- Adopting Continuous Delivery
- Architecting for Continuous Delivery
- Stop Hiring DevOps Experts and Start Growing Them
- What is Value?
- Why Scaling Agile Doesn't Work
- You Can Have It All: Software Development at Ludicrous Speed
- Adventures in Functional Programming
- Decoupling from Rails
- The Building Blocks of Modularity
- Here be Dragons
- Overkill
- Succession
- Therapeutic Refactoring
- Accelerating Upside: Convexity in Software Development
- Creating JUnit
- Extreme Programming 20 years later
- Fresh Work: 80/15/5
- Half-done Versus Fake: The Intermediate Result/Mock Tradeoff
- How to Get a Paper Accepted at OOPSLA
- Managing By The 'Book
- Mastering Programming
- My Convex Career
- Paint Drip People
- RailsConf 2015 - Closing Keynote
- Rapid Release Cycles for Convex and Concave Projects
- Responsive Design
- The Product Development Triathlon
- The Return of the Waterfall
- You Always Tell Stories to a Five-Year-Old and Other Lessons from a Storyteller
- Immutable App Architecture
- Immutable User Interfaces
- Overcoming the one weakness of OOP
- TDD with mocks and spies
- The 3 inspiring principles of microservices
- AbundantMutation
- AccessModifier
- Anemic Domain Model
- AntiPattern
- Beck Design Rules
- BlueGreenDeployment
- Boiled carrot
- Born for it
- Branch By Abstraction
- CQRS
- CanaryRelease
- CircuitBreaker
- CommandQuerySeparation
- Continuous Integration
- DIP in the Wild
- Data Clump
- Data Transfer Object
- DevOpsCulture
- Explaining Agile
- Feature Toggles
- FlaccidScrum
- FoundationFramework
- FrameworkBuilding
- Getter Eradicator
- HarvestedFramework
- ImmutableServer
- InMemoryTestDatabase
- Infrastructure As Code
- Inversion Of Control
- Is Design Dead?
- ListAndHash
- Making Architecture Matter
- Microservice Trade-Offs
- MicroservicePremium
- Microservices
- Microservices Video
- Mocks Aren't Stubs
- Monolith First
- NoDBA
- Not Just Code Monkeys
- ObjectMother
- ObservedRequirement
- PageObject
- Passive View
- Refactoring a javascript video store
- Replacing Throwing Exceptions with Notification in Validations
- ReportingDatabase
- SacrificialArchitecture
- SelfTestingCode
- ServiceOrientedAmbiguity
- Strangler Application
- Test Coverage
- Test Pyramid
- TestDouble
- Testing Resource Pools
- Transaction Script
- UserStory
- We cannot measure productivity
- What is failure
- Workflows of Refactoring
- Yagni
- with Molly Dishman - Agile Architecture
- Hexagonal Rails
- Treating objects like people
- NO. La sottile arte di trovare il tempo
- Bureaucratic tests
- L'arte perduta di pensare ad oggetti
- OOP is underrated
- Pattern: Testable Screens
- Selected TDD Resources To Start
- TDD Resources
- TDD for Android
- The Hexagonal Architecture
- Stunting a Framework
- Taking Automated Tests Off The Pedestal
- The Deep Synergy Between Testability and Good Design
- The Ethics of Error Prevention
- Using Repository Analysis to Find Single Responsibility Violations
- Goto Fail, Heartbleed, and Unit Testing Culture
- The Chris/Jay Continuous Build
- Changing Developer Behaviour, Part 1
- Changing Developer Behaviour, Part 2
- Checked exceptions I love you, but you have to go
- Flaw: Brittle Global State & Singletons
- Flaw: Class Does Too Much
- Flaw: Constructor does Real Work
- Flaw: Digging into Collaborators
- Guide: Writing Testable Code
- How to Write Clean, Testable Code
- Root Cause of Singletons
- Singletons are Pathological Liars
- The Clean Code Talks - Don't Look For Things!
- The Clean Code Talks - Global State and Singletons
- The Clean Code Talks - Inheritance, Polymorphism, & Testing
- The Clean Code Talks - Unit Testing
- Top 10 Things I do on Every Project
- Top 10 things which make your code hard to test
- Where Have All the Singletons Gone?
- Encapsulation is not Information Hiding
- Message Obsession
- Mock Roles Not Object States
- Refactoring Interfaces
- Test Data Builders: an alternative to the Object Mother pattern
- Two Hypotheses per Test
- Working Effectively with Legacy Tests
- Adam Wathan - Chasing "Perfect"
- Ciaran McNulty - Why Your Test Suite Sucks
- Coby Chapple - Remote by Default: How Github Makes Working Remotely Not Suck
- Cost of Delay - Black Swan Farming
- Crash-only software: More than meets the eye [LWN.net
- Dan North - Software that Fits in Your Head
- Dan North and Chris Read - Agile Operations – Optimizing the Business One Shell Script at a Time
- Danilo Sato - Parallel Change
- David Nolen - The Functional Final Frontier
- David West - OOP is Dead! Long Live OODD!
- Drive: The surprising truth about what motivates us
- Edward Kmett - Stop Treading Water: Learning to Learn
- Emily Bache - As a Professional Programmer, how do you learn new skills?
- Etsy - Continuously Deploying Culture
- GitHub does dotfiles - dotfiles.github.io
- Guida Galattica per Agilisti
- How to Read a Technical Paper
- Ian Cooper - TDD, where did it all go wrong on Vimeo
- Jeff Patton - Embrace Uncertainty
- Jeremy Thomas - Web Design in 4 minutes
- Jessica Kerr - Functional Principles for Object Oriented Development
- Joe Damato - Infrastructure as Code Might Literally Be Impossible
- Joel Spolsky - The Law of Leaky Abstractions
- John Allspaw and Paul Hammond - 10+ Deploys Per Day: Dev and Ops Cooperation at Flickr
- Joshua Bloch - How To Design A Good API and Why it Matters
- Kathy Sierra - Making Badass Developers (Serious Pony)
- Konstantin Kudryashov - Design How Your Objects Talk Through Mocking
- Lasse Ziegler - The Good Product Owner - A path to become great
- Liz Keogh - A Dreyfus model for Agile adoption
- Mathias Verraes - Unbreakable Domain Models
- Mattia Battiston - Metriche Kanban in pratica a Sky UK
- Measuring Microservices
- Obie Fernandez - Do the Hustle
- Opensource Licenses
- PHP - Efficient data structures for PHP 7
- Panda Strike - Flaws In Scrum And Agile
- Peter Alvaro - I See What You Mean
- Practical Tools for Playing Well with Others
- Presenter First Resources
- RailsConf 2015 - Implementing a Strong Code-Review Culture
- Richard Kasperowski - Building Great Teams
- Ross Tuck - How We Talk About Tech
- Roy Osherove - JS Unit Testing Good Practices & Horrible Mistakes
- Software architecture vs code - Coding the Architecture
- Structure and Interpretation of Computer Programs
- Stuart Sierra - Components Just Enough Structure
- Sven Peters - Rise of the Machines: Automate Your Development
- The Pragmatic Bookshelf - Tell, Don't Ask
- The Twelve-Factor App
- Tom Stuart - Refactoring Ruby with Monads
- Understanding Coupling and Cohesion
- User Story Mapping in Practice
- Valve - handbook for new employees
- We Are All Awesome!
- What is leadership?
- William Cook - A Proposal for Simplified, Modern Definitions of "Object" and "Object Oriented"
- William Durand - Object Calisthenics
- Your Path through Agile Fluency
- neomatrix369 - TDD good habits manifesto
- A short history of Software Engineering
- Hunters and Gatherers
- Java viene da Marte Ruby da Venere
- Keynote 2010
- Processo al database
- The frog problem
- TDD01IT Il microciclo del TDD
- TDD02IT Il prossimo test
- TDD03IT Dependency Injection
- TDD04IT Mock Objects
- TDD05IT Design Evolutivo
- Come scegliere un coach agile?
- I’m Not a Servant - I’m a Host! A New Metaphor for Leadership in Agile?
- Conference Club
- Extreme Programming Myths & Legends Busted
- Are We There Yet?
- Clojure
- Clojure Made Simple
- Design, Composition, and Performance
- Inside Transducers
- Persistent Data Structures and Managed References
- Simple Made Easy
- The Database as a Value
- The Value of Values
- Transducers
- Concurrency Is Not Parallelism
- Generating code
- Go at Google: Language Design in the Service of Software Engineering
- Essential XP: Emergent Design
- The Backlog
- All the Little Things
- Less - The Path to Better Design
- Madam Sandi Tells Your Future
- Magic Tricks of Testing - Ancient City Ruby 2013
- Nothing is Something
- SOLID Object-Oriented Design
- Crafted Design
- Does TDD really lead to good design?
- Explanatory Methods
- Functional is cool, but do you know OO
- Interaction Driven Design, How can we quickly
- Outside In TDD part I
- Outside In TDD part II
- Outside In TDD part III
- Software Craftsmanship
- TDD and Software Design
- Test-driving algorithms
- Testing and Refactoring Legacy Code
- The Long Road
- Agile Metrics
- Engineering culture (part 1)
- Engineering culture (part 2)
- Agile is not now, nor was it ever, Waterfall.
- Agility and Architecture
- Clean Architecture
- Craftsmanship and Ethics
- Demanding Professionalism in Software Development
- Extreme Programming, a Reflection
- FP Basics
- Is SOLID A Good Idea?
- Keynote: Architecture the Lost Years
- Mutation Testing
- Principles Of Ood
- Screaming Architecture
- The Clean Architecture
- The Cycles of TDD
- The Future of Software
- The Lurn
- The Prime Directive Of Agile Development
- The Programmer's Oath
- The Transformation Priority Premise
- Three Paradigms
- A step by step introduction - XPeppers Tech Talks
- Erik Falor - From Vim Muggle to Wizard in 10 Easy Steps
- From Essentials to Mastery
- How GitHub (no longer) Works
- How GitHub Uses GitHub to Build GitHub
- Remote-First vs. Remote-Friendly
- Tips for Public Speaking – speaking.io
- Unsucking Your Team's Development Environment
- What They Don't Tell You About Public Speaking
- A Critique of Use Cases
- Creating Good Domain Models
- Designing Flexibility (Against Client's Wishes)
- Extreme Programming
- Refactoring
- Should Distributed Objects Be Stateless?
- The Origins of Object Orientation
- What Makes A Good Object-Oriented Design?
- What's Wrong With Comments?
- the joebew42' study path