text stringlengths 0 2.35k |
|---|
**Angelica Hill:** Do you have a bit more as to why? |
**Kris Brandow:** Yes, actually. So when the van Neumann architecture was created, we were still using discrete parts. But even when we made that first transition in the '70s to transistors, we had on the order of thousands of transistors operating at kilohertz. And now, as of a couple weeks ago, you can buy a chip, bu... |
So jettison the van Neumann architecture, and along with it C and C-like languages... Which unfortunately includes Go as of right now, because while you can write some good concurrent code in Go, it's still pretty difficult. We want languages that look more like Erlang, or at least have the same underpinnings of things... |
**Angelica Hill:** Yeah, that may be an unpopular one... Especially if you add in that very blaze like "Oh, Go is included." |
**Kris Brandow:** I mean, Java, Go Rust, C, C++... All those popular imperative languages, just - goodbye. Time for something new. |
**Dominic St-Pierre:** Let's rewrite Linux in Erlang. It will be fun. |
**Angelica Hill:** So on that fine point, "Let's get rid of Go", regrettably, that is the end of our episode. Thank you all, it was an absolute pleasure having you on, and I hope we'll have you all back very soon, subject to how unpopular your opinions are. |
• Defining and viewing "legacy" as a neutral or even positive term |
• Classification of legacy code as good or bad, similar to debt |
• Applying the concept of legacy code to software development, specifically in Go programming language |
• Introduction to Sourcegraph, a universal code search tool for big code bases |
• Discussion on preventing legacy code from creeping in with a panel of guests |
• Legacy software is defined as outdated and difficult to maintain, often requiring specialized knowledge. |
• Factors that contribute to legacy software include lack of unit tests, poor documentation, and age (20+ years). |
• Go applications can be considered legacy if they are no longer well-supported or require significant maintenance efforts. |
• Legacy code can also be subjective, depending on individual opinions and experiences with the system. |
• Indicators of legacy systems may include difficulty working with the code, outdated architecture, infrastructure, or dependencies. |
• Legacy dependencies can refer to external libraries or frameworks that are no longer maintained or are causing performance issues. |
• Strategies for dealing with legacy dependencies include caching data, monitoring latency metrics, and testing for optimization. |
• Defining legacy code and its negative connotations |
• Conceptualizing maintenance as part of the development process |
• The difference between good and bad legacy code |
• The importance of testing in maintaining codebases |
• Challenges with refactoring and rewriting legacy code, especially in small companies or projects without resources |
• Discussion on when to focus on good design documentation and practices to ensure maintainability. |
• Mitigating test coverage requirements and potential backfiring |
• Concerns about legacy code in Java and its impact on maintenance |
• Advantages of the Go language, including simplicity and lack of legacy |
• Backward compatibility and tooling as factors in maintaining legacy-free codebases |
• Comparison of Go's ecosystem to Java's, with implications for upgrading versions and dependencies |
• Compiling legacy Go code with new compilers |
• Challenges in upgrading .NET platforms and tooling |
• Legacy system migration difficulties and vendor support |
• Working with closed-source vs open-source systems and dependencies |
• Potential for language fork or bifurcation in the face of community pressure |
• Benefits of working with a vibrant and supportive community like Go's |
• When to stop maintaining legacy code and start over with a new implementation |
• Factors to consider when deciding whether to rewrite or maintain existing software |
• The importance of business and product alignment in making this decision |
• The impact on engineers' quality of life and career growth when maintaining legacy code |
• Personal preferences vs. skill level in determining whether an engineer enjoys maintenance work |
• Different types of engineering, not levels of experience or time in field |
• Importance of balance between R&D and maintenance engineers |
• Criticism of tech companies prioritizing new development over maintenance |
• Challenges of advocating for maintenance and codebase updates |
• Approaches to communicating the importance of maintenance as a cost center with long-term implications |
• Using the concept of "tech debt" to explain maintenance needs and potential future costs |
• Technical debt and its impact on engineering organizations |
• Importance of quantifying technical debt for prioritization and planning |
• Difference between legacy code and technical debt |
• Challenges in paying down technical debt due to lack of understanding or quantification |
• Potential for new types of engineering jobs to emerge due to increased software creation |
• Technical debt and legacy systems should be quantified in probabilistic terms |
• Business people should understand the bottom line impact of technical debt |
• Engineers should use business-friendly language to communicate about technical debt |
• A new type of engineer is needed to focus on analyzing and prioritizing technical debt |
• Companies need a robust framework for discussing and managing technical debt |
• Ceremony and meetings can be a waste of time if they don't lead to actual action |
• Legacy code creeping into systems can be prevented with proper testing, investment in infrastructure, and monitoring |
• Test-driven development is a helpful tool for preventing legacy code, but not a cure-all solution |
• Rewriting software as an entire system is scary and can be avoided by making small changes over time |
• Writing documentation and comments is essential for understanding the intent of code and preventing bugs |
• Importance of clear intent and naming conventions in code |
• Benefits of proper documentation, testing, and coding standards |
• Value of taking extra time to think through problems and iterate on solutions |
• Role of gut instinct and following one's inner voice in code design |
• Potential benefits of pair programming and group design in preventing legacy code |
• The challenges of rewriting legacy code bases |
• Importance of understanding why rewriting is necessary |
• Need for architecting new solutions with legacy in mind |
• Design considerations to avoid future legacy issues, such as microservices and decoupling |
• Importance of historical context when rewriting systems |
• Challenges and potential pitfalls of rewriting entire platforms |
• The risks involved in rewriting legacy software |
• Exceptions where a complete rewrite may be warranted |
• Factors to consider before deciding to rewrite software |
• Importance of assessing the cost and complexity of a rewrite |
• Criteria for determining whether a rewrite is justified |
• Limitations and challenges of rewriting versus refactoring or improving existing code |
• Criticism of Greenfield rewrites as a development approach |
• Importance of maintaining existing codebases instead of rewriting from scratch |
• Challenges and difficulties of separating new features from legacy code |
• Analogy of software maintenance to lawn care, emphasizing the need for ongoing effort |
• Humorously discussing the limitations and flaws in the concept of starting with a "Greenfield" |
• Announcing the expansion of the podcast series to focus on software maintenance and legacy code |
• Unpopular opinions segment on the podcast |
• Jeff shares he doesn't like any type of yogurt |
• Chris and others share their reactions and personal preferences regarding yogurt |
• Discussion about the benefits of yogurt, specifically Greek yogurt, including its effects on digestion |
• Probiotics are mentioned as a component of yogurt with potential health benefits |
• The speaker discusses a probiotic beverage they take |
• The speaker proposes that CSS is a full-fledged programming language that will replace other languages, and would like to rewrite their backend microservices in it |
• A conversation ensues about the possibility of compiling code from other languages into CSS, including writing a C compiler that compiles C into CSS |
• Dominic invites Misha to write such a compiler in Go and discuss it on the show |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.