👆 Click on “Broadview” for more book news

“There are many metrics in the industry that measure productivity, such as executable file size, machine instructions, number of lines of code, number of statements, function point analysis, circle complexity, number of operators, number of tokens, etc. Why did the LOC (Number of Lines of Code) metric succeed in the end? ”

As a software engineer, you need to understand how productive a team or individual is in a project. You try to predict productivity by how a team or individual has performed in similar projects in the past, but when a new project comes along, past performance is less informative.

At this point, you need a measurement system that is smaller than the overall project granularity level. An ideal metric can be used across multiple projects for comparison between projects.

As a software engineer, you’ve used quite a few metrics until something better.

Those metrics that you used

Executable file size metrics: The calculation method is simple and does not require access to the original source code. However, because executables contain uninitialized data, although they increase file size, they have little or no relationship to the complexity of the system. In addition to that, library functions increase the size of the executable, but they actually reduce the complexity of the project.

Machine Instruction Metric: Its main drawback is that some executable formats contain uninitialized static variable spaces, which means that small changes to the source file can dramatically change the size of the executable file.

Statement count metric: It measures the amount of work done rather than the work done, it’s not as language-agnostic as we would like, and it assumes that the amount of work required for each statement in the program is the same.

Function Point Analysis (FPA): Unlike the number of lines of code or statement number metrics, it cannot directly calculate the number of “function points” in a program. FPA has never been able to successfully automate. It can’t analyze where a program counts as an end, and manual analysis is time-consuming and expensive.

McCabe Circle Complexity Metric: This metric is useful because it is an objective metric and can be calculated by writing a program. Its disadvantage is that it has nothing to do with the number of programs, that is, it treats a printf statement as if it were 1000 printf statements on a line.

Why the LOC (Number of Lines of Code) metric is so popular

You find that no matter what metric you use, it has drawbacks.

Many people try to use a combination of multiple metrics (for example, using the number of lines of code multiplied by the number of circles and the number of operators) to create more “multidimensional” metrics to better assess the effort when the amount of code is low.

Unfortunately, as metrics become more complex, they become more and more difficult to apply in a given project.

So why did the LOC (Number of Lines of Code) metric succeed in the end?

Because it has the following advantages:

Regardless of the programming language used, the time it takes to write a single line of source code is the same.

LOC metrics are not affected by libraries (or other reused code) used in your project (of course, assuming you don’t count the number of lines of source code that depend on libraries).

The LOC metric is CPU-independent.

These advantages come from the fact that it “uses LOC metrics, which are extremely convenient for statistics and can be done using off-the-shelf tools (such as wc under UNIX), while the use of other metrics usually requires writing an application that depends on a certain programming language.” ”

Therefore, since the current various metrics do not fully reflect the productivity of programmers, choosing a “better” metric will not have better results, which makes everyone more willing to use an easy-to-use indicator, that is, LOC.

Metrics are extremely important and difficult to explain in software development and R&D management, so they are easily overlooked.

It is said that when programmers first start software development, the idea is generally like this: write code without distraction, and things outside the code are extra overhead and waste of time.

After writing code for a few years, the projects involved in became more and more complex, especially after being a software development manager, I realized that programming is only one part of many aspects of software development, and only completing it is still a hundred and eighteen thousand miles away from the smooth delivery of a complete software system.

A good software engineering book can solve the pain and difficulty of software engineers in the software development process.

Randall Hyde’s The Way to Programming Excellence (Volume 3: Software Engineering), a collection of the author’s many years of practical experience and deep understanding of software engineering, can give you systematic guidance to help you find your own best practices and deal with the problems that arise one after another.

Through this book, you will learn: why following the software craftsman model allows you to do your best; How to use traceability to enhance document consistency; How to create your own UML requirements through use case analysis; How to develop better software using IEEE documentation standards.

Randall Hyde

The Art of Assembly Language and Write Great Code volumes 1–3 (both published by No Starch Press), and using 6502 Assembly Language and P-Source (published by Datamost).

Co-author of Microsoft Macro Assembler 6.0 Bible, published by Waite Group.

For the past 40 years, Hyde has been working as an embedded software/hardware engineer, developing instruction sets for nuclear reactors, traffic control systems, and other electronic devices. He also teaches computer science courses at the California Institute of Technology Pomona and the University of California, Riverside.

Zhang Ruofei

He has served as the CTO of a number of Internet finance companies, and served as an architect in well-known companies such as Yiren Loan, Yahoo Beiyan, and Kingsoft Cloud.

More than 10 years of Internet research and development and technology management experience, has rich experience in building massive data and large-scale distributed systems.

He is the author of more than ten technical translations, including “Grails’ Authoritative Guide”, “JavaSE 8 for Busy People”, “Code Immortality: Ten Principles for Writing Maintainable Software”, “Towards Scalable Architecture”, “Cloud-Native Java” and other books, totaling more than 4 million words.

This book from Randall Hyde, a big coffee with more than 40 years of experience in the industry, is a very good work in the field of software engineering, with a solid theoretical foundation, a summary of the author’s rich experience, and also gives a lot of engineering design and document examples with reference value, covering the preferences of different readers. If you are interested in becoming an excellent software engineer, want to design and develop a software system that has lasted for a long time, continues to generate value for business scenarios, and contributes to the progress of the country’s software industry, then it is a good choice to keep this book on the record and practice diligently.

——Zhou Yuan, co-founder and chief scientist of Guanyuan Data

Software development is a systems engineering, and it is not just a matter of many beginners thinking of locking themselves in a room and tinkering with code, but involves dealing with many different people and things in all aspects. If you haven’t been involved in the development of large commercial software before and aspire to become a professional product manager, software engineer, test engineer, SCM, or project manager, don’t miss The Way to Programming Excellence (Volume 3): Software Engineering. With this book, you can quickly grasp the key knowledge points covering the entire life cycle of software development, accurately assess the challenges you face, and communicate with others with less effort.

——Gao Yuxiang, translator of Scala Programming, senior software development engineer and system architect

Since the agile movement, the work of writing source code in software development seems to be increasingly disliked, especially when writing documentation. However, truly experienced people don’t think so—they think about how to write the right documentation at the right time. Let’s take a look at what Randall Hyde thinks and does as an “old man”.

——Dong Yue Author of “General Knowledge of Software Delivery” and senior expert of DevOps

I have worked on projects from scratch, maintained legacy code that is nearly thirty years old, and experienced many changes in requirements, personnel, etc. as the project progressed. Over the years, I have been learning and thinking about what kind of software development model can effectively cope with the various uncertainties in the software life cycle, how to improve the readability and maintainability of code and documents and ensure consistency between them. I recently had the pleasure of reading The Way to Programming Excellence (Volume 3): Software Engineering), in which author Randall Hyde explores these issues in depth. I believe that other readers, like me, will be able to draw valuable experience from this book to lay the foundation for future career development.

——He Haitao, author of the best-selling classic “Sword Finger Offer”, former senior development expert of Microsoft in the United States

This book provides an informative “hard skills” guide for outstanding professional software engineers. Although this series of books is called The Way to Programming Excellence, the content has gone far beyond programming itself. This book provides a complete outline of the knowledge and skills of outstanding software engineers, allowing you to re-understand programming from the perspective of software engineering, helping you to quickly understand and master the professional skills and knowledge systems necessary for outstanding software engineers in the world today. While the books in this series are “tomes,” the content of each chapter is not to be missed.

——Gu Yu, translator of “Effective Engineer”, Tencent T11 expert

This book makes a wonderful introduction to the concepts and fields of software engineering, with appropriate details, focusing on the most classic and practical software engineering knowledge, on the basis of which it discusses how to balance the considerations of teamwork, the outstanding contributions of individual programmers, and the growth path of programmers themselves, which is a rethinking and understanding of software engineering systems on a broader level. The text of this book is concise, the translation is accurate and fluent, and it is worth reading carefully.

——Sudan (screen name su27) Translator of “Python One Line Stream”, head of the backend of Douban user products

The Way to Programming Excellence (Volume 3): Software Engineering systematically summarizes the basic paradigms and best practices of the programming process, and provides an in-depth discussion of staffing, metrics, scheduling, documentation and other aspects of project management, with detailed use cases. Software engineering and management personnel can get useful references from this.

——Tian Yuandong Meta (formerly Facebook) Artificial Intelligence Research Institute (FAIR) researcher and senior manager

For many beginners to programming, there is still a huge gap between learning the programming language and completing a real software. Like the famous syllab, an example program can run successfully once, while a piece of software to be delivered to the user is meant to run at all times. Turning an example program into deliverable software requires the help of software engineering.

The Way to Programming Excellence (Volume 3): Software Engineering” is a book that answers this question.

Starting with classical software engineering, this book discusses the measurement of software development efficiency, the development methods that were once popular, and the agile development that is now in vogue. It allows the reader to glance at the history of software engineering and understand the progress of different stages of development. The subsequent UML and software engineering documentation introduces a variety of practical software engineering techniques from an operational perspective. Communication between humans is very inefficient, and UML and documents are convenient means to improve communication efficiency and reduce duplication and ineffective communication. It is believed that through this book, readers can learn many methods and techniques in the field of software engineering, and achieve greater efficiency in future software development projects.

—Liu Xiaoming (gashero) software development expert

Modern programming work is no longer an era of individual heroism alone, but a greater emphasis on the output of the team collective. This book covers the classic models of modern software engineering, as well as various details – process, such as hackathon programming, waterfall models, iterative models, etc.; In the details, if focusing can improve work efficiency, standing will avoid endless procrastination of meetings. In addition, it describes how requirements documents, software design documents, and test documents should be written. Whether you’re a technical leader, a project manager, or an ordinary employee, it’s important to understand modern software engineering. Only in this way can individuals better play their value in the team.

——Zhang Yanfei is the author of “Deep Understanding of the Linux Network”, the founder of the public account “Development Internal Cultivation”, and a former Sogou expert development engineer

This book is the third volume in the “The Way to Programming Excellence” series, focusing on software engineering. After trying it out, I recommend it to computer science graduates and programmers in the workplace who are coding on the front line. For computer science students who have just entered the workplace, this book can not only let them quickly understand the complexity of software development in the enterprise, understand every aspect of software engineering, but also through the definition of excellent programmers in this book, compared with their own capabilities, quickly grow from a rookie programmer to an excellent programmer. For programmers with some experience in the workplace, this book can provide a reference for solving problems encountered in software engineering, such as what practices are best, how to enhance document consistency, and so on.

——@ orange a boy know the programmer excellent answer to the senior algorithm engineer

JD has a limited time limit of 100 minus 50

Publisher: Liu Enhui

Review: Chen Xinyi


 Hot text recommended  

Book list | September book courier

Four types of process management software

What are the core competencies that P5~P9 should have?

What steps do I need to customize a chart? Teach you hand in hand

▼Click to read the original article to learn more about this book~