Does this bald guy feel benevolent? His name is Martin Fowler. Who is he? Why is there such a person in a programmer’s blog, because he is bald?
But if I told you that he rarely talked about operating systems, databases, networks, and other low-level things, and rarely heard him talk about high concurrency and mass users, he didn’t develop any well-known software, but he was regarded as the “godfather” of software development. What do you think!! But it is true
If you follow the programmer’s mindset, you layer the software
He actually lives at the top:
This floor is crowded with programmers, because the lower you go, the harder it gets. You have to be able to withstand loneliness, to withstand temptation, to have a very profound study of a particular field.
Martin Fowler, however, has been a big voice on the application layer because of his special ability to summarize some software development practices into “concepts.”
Obviously, this requires a great deal of abstraction.
Martin Fowler is definitely a role model for programmers who develop at the application level!
Why? Because he is too friendly to application layer developers, and most programmers are also stuck in the application layer, for example, he is now working on the pattern of the related problems, the beginning of the direct introduction of distributed system several general problems:
A process be crashed
Network latency
Process pause
An out-of-sync clock
Then it introduces how the distributed system solves these problems.
For example, the classic write-Ahead Log mode can be used to persist data in the event of a process crash:
The data is stored in the persistent log file as a Command, so that even if the KVStore process crashes, the data can still be recovered from the log after the restart.
It was nice of everyone to immediately provide a simple snippet of code to help understand the details, knowing that the language of programmer communication is code.
The class KVStore... public KVStore(Config config) { this.config = config; this.wal = WriteAheadLog.openWAL(config); this.applyLog(); } public void applyLog() { List<WALEntry> walEntries = wal.readAll(); applyEntries(walEntries); } private void applyEntries(List<WALEntry> walEntries) { for (WALEntry walEntry : walEntries) { Command command = deserialize(walEntry); if (command instanceof SetValueCommand) { SetValueCommand setValueCommand = (SetValueCommand)command; kv.put(setValueCommand.key, setValueCommand.value); } } } public void initialiseFromSnapshot(SnapShot snapShot) { kv.putAll(snapShot.deserializeState()); }Copy the codeBut what’s going to introduce this old man today? Because there are so many distributed theory articles on the download web, dry, can not read a page on the want to give up. There are plenty of source code analysis articles on the web, too, but the focus is on sticking to code and getting bogged down in detail, which can be confusing.
Unmesh Joshi’s distributed system model is a good balance: it has theory and code details.
1, if you are a novice to the industry, it may be difficult to see these things, because you need to have the foundation of distributed system, may wish to collect first, wait for later to see.
2. If you’re an experienced veteran, I highly recommend you take a look and see how these people extract common patterns from complex scenarios. You might think: Why didn’t I think of this kind of work?
Of course, this is English material, there will be some obstacles, but as you can see, there is no advanced vocabulary, LET me list a few sentences for you to feel the feelings:
Processes can crash at any time. Either due to hardware faults or software faults. There are numerous ways in which a process can crash.
It can be taken down for routine maintenance by system administrators.
It can be killed doing some file IO because the disk is full and the exception is not properly handled.
It’s not that hard, right? Give it a try. Reading English materials is also an important skill.
Finally, here are some of Martin Fowler’s most famous books
Domain-specific Languages
Speaking of DSLS, I only want to emphasize two points:
First, increase developer productivity;
Secondly, improve communication with experts in the field.
When chosen well, DSLS can make a complex piece of code clear and easy to understand, increasing programmer productivity when using the code. At the same time, if the DSL is chosen well, a common piece of text can be used both as executable software and as a function description, allowing domain experts to understand how their ideas are reflected in the system, and allowing developers and domain experts to communicate more smoothly. Improving communication is harder than improving productivity, but the results are more significant. Because it helps us break through the narrowest bottleneck in software development — the communication between the programmer and the customer.
Enterprise Application Architecture Patterns
Enterprise application development practices thanks to the emergence of a variety of new technologies, multi-layer object-oriented platforms (such as Java,.NET) have become increasingly common. These new tools and technologies have the ability to build more powerful enterprise applications, but they are not easy to implement. Common mistakes often occur in enterprise applications because developers do not fully understand the architectural experiences and lessons of experienced object developers.
“Refactoring”
Refactoring is the process of making changes to code to improve the program’s internal structure without changing the code’s external behavior. Refactoring is a disciplined approach to refactoring that minimizes the chance of introducing errors into the process. Essentially, refactoring is improving the design of code after it has been written.
Analysis Patterns
The analysis patterns described in the book, while containing a great deal of domain knowledge, are applicable to all business software. Like design patterns, these analysis patterns are abstract enough to help your software adapt to changing requirements; At the same time they are very specific and easy to understand. They are not the most obvious solutions to modeling problems, but I think they are the right ones. I’ve seen many of these solutions before, and they all work well
