google

Pipeline, Geometric Decomposition, Data Parallelism

2009-11-04T20:17:00.000-08:00

Geometric Decomposition

This pattern is another use of divide and conquer, divide up the data structure and do computation at each unit. I did not find this pattern interesting. Although in the task schedule part, the author express a preference on static cyclic allocation, I think it is hard to keep the load balaced when the computation become sparse. And for the dynamic scheduling, overhead is a big problem. A combinition of the two might help, static first, then switch to dynamic when reaches some threshold.

I think the most challenging part of this pattern is the update operation, cautions and supervisions are necessary.

Data Parallelism

Alright, this is all? Shortest pattern that I've ever read. A pattern looks very likely to Geometric Decomposition, but view it in another dimension, which is keep the data chunk fixed and move the command sequence on them. I am not sure how to combine those data chunck during the processes though. I don't think it is anything like the MapReduce because I could not find in the description of how to combine those data sets. Maybe as it said "When the operations are for the most part uniformly applied to these elements, an effective solution is to treat the problem as a single stream of instructions applied to each element." it does not contain the combine part. Still, I could not see this pattern very in a useful way.

Pipeline

As its name tells us, this pattern is about dividing work into simple steps, set up multiple stations and each station works based on the production from previous one then send to the next. The biggest challenge is to divide the work in order to have a fairly similar runing time on each station to avoid bottleneck. I think the idea is much like the Data parallelism, but this pattern is described in a more understandable way and provides a lot more details. I actually read this pattern after the Data Parallelism and I think I'm wrong about no combination in Data Parallelism Pattern. The combination itself should be a station and the data to combine can be send as works or just messages.

Armstrong Chapter 5

2009-11-03T14:01:00.000-08:00

This chapter describe a method in programming fault-tolerant system: the supervisor and hierachy of tasks. I think this kind of hierachy is very efficient in error handling in a way that the supervision processes are very important, especially in identify the errors.

Recently,we see a lot of this kind of "divide and conquer" ideas in patterns and parallel programming, I think the supervisor and the hierachical way of managing is a variant of this central idea.

Task Parallelism, Recursive Splitting and Discrete Event patterns

2009-11-02T19:29:00.000-08:00

Task parallelism
I think this pattern is really straight forward by the name if you read the content first. This pattern should belongs to structural pattern because basically it describe a abstract structure. I think better run times can be get from software as well as from hardware. Sometimes a better implementation can save us some time. I believe this pattern is not platform relavant, but yes I think learn more about hardware platform can make a better implementation sometimes.

Recursive Splitting
I found this pattern somehow interesting, because there is nothing really new in this pattern, but it is described in a more computational way. And this pattern is able to add some other patterns to it.

Discrete Event Pattern
I like the message passing most, but under some circumstances, shared-memory can be easier to use, maybe abused a lot. I think the accurate deadlock detection can be hard but simply timeout can be misleading too. Sometimes we do want to know if it is the deadlock or other problems cause timeout.

Dense Linear Algebra,

2009-10-22T14:22:00.000-07:00

I haven't use or heard those patterns.

I think the Dense Linear Algebra is easy to understand and the author try to make it easier to understand by using a lot of picture to illustrate.
For Graph Algorithm Pattern, I think I see enough definition in the paper that can help understanding the problem. Monte Carlo Pattern gives two examples which I found useful in understanding the pattern.

To me the computational pattern and the structual pattern are all aiming at efficiently solving certain problem. Structual patterns ease the design by building up relationships between entities in a simple way; Computational patterns find the best math model for the problem in the solution space. Hmmm, I will say the distinction is fuzzy.

Small problems that I have when reading through the patterns.

For Dense Linear Algebra, in performance analysis, isn't O(N^3) > O(N)? Why it seems like BLAS level 3 stand out?

Armstrong Thesis Ch 2.

2009-10-20T15:57:00.000-07:00

I think the six descriptions are great guidelines of characterizing the software architecture. If I try to describe a system, I might use the some of them, probably not all. I don't see the necessity of the construction guidelines in majority of the system descriptions.

I don't have much experience in parallel programming, and I don't remember that I've ever worked with a system with inter-process communication solely via messages. I'd like to hear some examples tonight.

I think the "fast-fail" idea is suitable with the requirement of the system, which has a lower tolerance of fault. I think in the Thesis, the author lists some properties that needs to be built in such as a failure status need to be recorded and the isolation of crashed processors.

I think it is a good decision to make for treating the messaging layer as unreliable in the telecom environment that is working. The tradeoffs will be the additional confirmation in the system.

Event based implicit invocation & Map reduce

2009-10-19T20:02:00.000-07:00

Event based implicit invocation

I think the difference between this event based pattern and observor pattern is the medium. The similarity exists in that both of the patterns do some decoupling job to separate the publisher and subscriber to get better scalibility. And event based pattern uses medium as a hub to receive/dispatch the event whileas the observor is one to one.

Implicit invocation makes it ideal for broadcasting and requires less process for the medium. I don't know about the security here to broadcasting.

I think the "standard" messaging mechanism can only be achieved flexibly using a "middle man", since the one to one relationship is not good in adding new members. An extra layer of abstraction is needed here.

I think that kind of structrue is widely used in distributed system. The main error handling should reside in the "hub" so that error messages can be passed along or to be handled. But there should be some simpler error handlings in "node" too, in case the "hub" fails.

Map reduce

For some reason, when I saw this master-worker pattern, I immediately thought of the propagation of Storm, they share the same concepts of managers and workers. And because of this really efficient way of managing the robot machine, that spam spread very quickly around the world and I think parallel programming can be benefit from that too.

Refactoring for Reentrancy

2009-10-12T19:52:00.000-07:00

This is the third paper discussing about refactoring in paralellism. This paper is dealing a more difficault problem, creating a program that can be run in parallel on multicores without additional control or separate VM for each program instance. Like previous two papers, the refactoring of making program reentrant needs several steps that contains interactions with programmer. Same as the tools that are described in previous two papers, the paper lists some statistics to show the efficiency and correctness of this tool.

The tool uses the concept of Lazy Initialization, but as mentioned in the paper that the initialization code the reentrant tool generates may alter program behavior, which will probably makes this tool unuable in complex code that will read mutable static field in other class. And that I think is pretty common in systems of a certain size.

Beautiful Architecture Ch 14.

2009-10-12T18:56:00.000-07:00

I always find interesting topics in this book, and here comes what I am always waiting for: a chapter about a pure OO language, the Smalltalk! I found a lot of fun from Squeak in Smalltalk this Summer in another course taught by Professor Ralph Johnson. It's such a natual way in Smalltalk that objects interacting with each other through the messages. I think that gives this OO language a little bit favor of functional languages. The functions in Smalltalk are small yet powerful, the whole developing environment in Squeak is so convenient that I almost hate Visual Studio when I have to switch back to C# in my work.

One of the many interesting feature of Smalltalk is that it supporting "Duck typing", I recently found the support of this feature in C# too, the problem is C# is a strong typed language, and there is some debates in the internet about how to use the "Duck typing" in C#, or if it should be used. Anyway, I appreciate the duck typing in Smalltalk that give me another option of polymorphism.

Since Smalltalk's open environment, it seems to me that Squeak is turning into a big lab, new concepts are implemented and tested there and later on adopted by other languages. So even with so many cool concepts and architecture, it is not stable enough and not used much in industries.

I seem Smalltalk or Squeak as a system with beautiful architecture, I feel pitty that they are not known or used by many programmers. But I think that is one of the reason that they can always do something cool and never been done before. I can't imagine any main stream architecture will have the opportunity of doing that.

Relooper

2009-10-08T10:32:00.000-07:00

This paper describes another tool for semi-automizing the refactoring for parallelism. This tool is dedicatedly used for transformation of data structure that can run loop operation on it such as array. I think this paper is an enhancement of the previous paper.

In this paper, the author is able to identify the biggest problem of dealing the safty of parallelism in an array, which is the "race" problem. And the statistic analysis shows that Relooper is an efficient tool for code refactoring to create safe parallel loop code.

Beautiful Architecture Ch 13.

2009-10-08T07:45:00.000-07:00

This is one of the most interesting chapter in this book in my opinion. Although I found the comparison between the two does not always make sense. I think both type of languages (OO or functional) exists for certain reason. I only have experience with a couple of languages, (C++,C#, Java,Smalltalk)OO or functional(OCamel). To me, OO languages are more modulized and easy to apply the "reuse" concepts. While functional languages are more flexible in structural, I like the convenience high-order function brings. Especially powerful when you can use small functions and use the result of a function as the input of another. You can get things done with shorter coding in functional languages than in OO. This is not always, you can get fairly small functions by using Smalltalk too. I don't have the same "easy to use" feeling in some OO environment such as C# though. But since functional language is more flexible, it takes more time for me to understand the function if it is embedded several layers of functions from my experience with OCamel. Maybe it just takes time to get use to it, like it takes time for me to turn from structural languages such as PASCAL to OO language C++ at first. I don't think it is fair to compare this two languages at certain level that they are just not comparable at all. Because they are designed differently for different purpose.

Refactoring Sequential Java Code for Concurrency via Concurrent Libraries

2009-10-06T09:13:00.000-07:00

Refactoring process is tedious, and desparately need suppoorts from tools. In this paper, a tool called Concurrencer is introduced to reduce the pain of this tedious, error prone process. I believe they are on the right track of refactoring in parallel that semi-automatical convertion is less painful and much quicker solution for the transformation. The paper lists three possible use of that tool: AtomicInteger, ConcurrentHashMap and ForkJoinTask, and gives detailed example of each use case. I find it is easy to understand.

In the end of the paper, it lists some statistical result, trying to prove that Concurrencer is an efficient and useful tool for performing such convertion tasks. I am curious if they can extend that tool to support other more complicated parallel-programming structures. I think integer increment, hash map operation and fork join are pretty simple, structual wise. Especially for fork join, majority of the divide and conquer functions are simple when using recurrence. I think to make this tool more soundly applicable for industrial use, they need to have more complex structure transformation covered by this tool.

Java Fork/Join Framework

2009-10-01T17:58:00.000-07:00

In this paper, the author trying to introduce the fork/join framework as a lighter parallel programming architecture comparing to threads so that ca be more protable for JVMs. The framework is able to break runnables to a fairly small workload and pass that on to workers. I think this framework is suitable for programs that are needed a lot of "simple" workers, rather than a more complicated counterpart. I believe it shows a great performance advance for recurrsive type of work, not sure about more complex ones.

Beautiful Architecture Ch11.

2009-09-30T15:47:00.000-07:00

I did not really heavily used Emacs before I read this Chapter, but I would like to explore more after today. The time that I uses Emacs limited to the condition that I worked on a Unix system or telnet to a linux system. But the only reason I used Emacs is for opening the file with several lines of code changes then closing it. In this Chapter, the author shows me a more advanced use of Emacs, which reminds me about another powerful similar structrue, browsers in Squick. I love the universal browser in Squick, a very easy to use browser, and Emacs seems to have a lot of functions integrated into too.

Architecture wise, Emacs adopts the typical MVC pattern. And it seems like the buffer management of Emacs is really strong that even "crash", user still can retrieve data from the buffer. Emacs can be extended, but maybe because of this, it is turning into a "big ball of mud". I'm not sure if another text editor with sililar architecture will be produced to replace Emacs, but it seems a haul is needed for it in near future.

OPL

2009-09-29T07:11:00.001-07:00

The author introduces a design pattern for parallel-software engineering called "Our Pattern Language". I really do not appreciate the name of that pattern, since it is not intuitive enough to tell me what that Pattern Language is about and it can be used to any other pattern languages. Although it is said that OPL is not specific to any particular application domain, the author can add some more distinguishing words to it, such as Our Pattern Language for design of parallel software.

Then in the main body of this article, the author divided the tasks into several different buckets and threw some patterns in each bucket. Well, I have to admit that this is far away than what I have expected when seeing the title and follow all the way down to the end. What I expect is a real language with the elements that are defined for describing a certain scenario of problems in parallel-software engineering instead of a set of patterns that can be used in parallel programming.

Maybe I should stop complaining about the ambiguity of the name. I don't have experience on parallel programming so I guess I can not tell if those patterns that are listed in OPL really helps developers or not. But one thing I think this project did is creating a manual for developers on design patterns. Sometimes I do want some summary of available, so called best practice, for a certain job structured by layers and as a whole too. So with that point of view, developers may benefit from this article.

Beautiful Architecture Ch 10.

2009-09-29T07:11:00.000-07:00

I think it is the third or fourth paper for VMs, this one is mainly focused on implementations. I like the details in runtime environment and it answers some of my questions in such as class loader and I found Optimizing compilation interesting too.

There are no architectural specialty in this article, is a good reading for knowing more in compiling/runtime properties of this JVM.

The Adaptive Object-Model Architectural Style

2009-09-24T15:56:00.000-07:00

Before AOM, people generate a lot of classes for different type of entity. Developers need to change the code whenever a business change happens. In AOM, entities are modeled by metadata, rules and constraints which can be changed quickly and affect the least of the system. I think AOM is a flexible architecture that it can be combined with many other design patterns such as Builder and Interpreter, but it currently has no generic framework for building the model. The author described three different systems that uses AOM, I can see they all share TypeObject and Property patterns, but the Strategy differs a lot.

The project in this article as an example of AOM is building a Refugee application, the model takes time to build, but once built, other components are easy to add on. That is the power for the AOM.

Beautiful Architecture Ch 9.

2009-09-22T08:26:00.000-07:00

I really like emulations over VMs when there are a rush task and I don't have to install a environment that I know I would not use often afterwards. One of the most used for me is Cygwin, which contains a emulation of Linux on Windows. It is easy to install, only contains essential components that is quick to boot up. I think the biggest convenience Cygwin brings to me is that I don't have to reboot my machine (I have another full version of Linux installed in my computer) to do a little bit of work in Linux while majority of the time I can get my jobs done using windows more quickly (I'm more familiar with windows environment). But I have to admit that sometimes the speed penalty of emulation does kill me. My bottom line is, if I have dedicated time to work on, I will use the real system/VM, if I need to do some higher priority works in Windows, I'll just let the emulator run at the background. Even though the emulator might just crash because of the bugs in my code, it will not affect me using Windows normally.

Normally I use exception to report errors, but there are some circumstances that I use exception to deal with absence of form field when assigning values in .NET.

Talking about the flexibility of emulators, there are another important factor that I can run multiple instances of emulators at the same time without worrying about interfering other instances. (Of course, I need to avoid working at same file directory among those instances.)

Big Ball Of Mud

2009-09-21T13:37:00.000-07:00

I think I saw a lot of systems which are like a big ball of mud during my work as a software engineer. And I believe I created some too. Other than those were created at my early career as a freshman in software development with little knowledge of what a good system should look like, majority of them are created by a rush work. Time was limited and we were kind of in a exhausted mode. Later on, there came the improvements and bug fixing. Not until we could not figure out some code error in a big chunck of function body that we realized we've defeated by this big junk of mud.

I don't think a big ball of mud can be avoided without a careful design, which is basically impossible at the first version of the system, if not several. Especially when the system you are working on have not been implemented before. I believe that user requirements are needed to be triggered, and the prototype system is needed at early stage of the system development. Since it is almost impossible for us to foresee what the future requirements would be, there are a big chance that after some time, the functions that are added on in a casual way will turn into balls of mud, until someday you get a huge one that forces you to rethink the structure. At early days, people do not realize the importance of reflectoring and prefer to rebuild the system from zero when they find the old system is not working right any more. I agree with the author that forming a nice architecture of the system takes time and I think customers are more happy when they see some real system running than seeing a carefully designed system diagram. Thus, "focus first on features and functionality, then focus on architecture and performance.

I think not all the throwaway codes are really throwaway since the code is still good in functional. It's because of the poorly organization of the code that cause the problem. Sweeping under the rug is an interesting idea and I believe that is good for relectoring too since you can put the ugly code under a facade but still keep the trivial functionality available using interfaces while you are focusing the reflectoring of main bone of the code.

I think the only reconstruction that I've ever experienced was because the functionality had changed a lot or some of the main functionality would not able to be created under the old roof. The other possible reason for reconstruction was the underlying platform change. Not surprisingly that a lot of organizations, majorly not for profit organizations tend to change platforms when personnels get changed in IT department. A director that has more .NET background will reconstruct the software that was written in Java. I've been through a project the person in charge is from java background and tried to change all the core applications into java from coldfusion.

Beautiful Architecture Ch8.

2009-09-20T20:22:00.000-07:00

Greg Lehey in this chapter described an architecture, Guardian, which is designed to provide efficient fault tolerence with the hardware support of Tandem

Tandam used the fault tolerent structure which is widely used now, the hot standby structure, for hardware components such as CPU, to back up the possible failure of one another. The system used a special bit in one of the register to distinguish and protect the procedure calls. Then by checking the offset of the instruction based on procedure type, load instructions or generate protection trap. There are two buses that are parallelly used and both functional and as back ups for each other. IO controllers can be used by only one CPU at a given time to reduce confliction. Each CPU owns a set of processes with PID.

To manage such a system which works basically like several system colaboration, a advanced message system is requried. The process pare is quite interesting to me since I know the checkpointing from DBMS. I don't know which sytem adopt this idea first but we can see some similar architecture between the two here. There is a difference that in some of the DBMS, the checkpoints are set automatically when some system threshold is met whereas Tandam needs the programmer to set up the checkpoint and I can already see there might be chances of malfunction of that mechanism.

As a fault tolerant system, the exploit of memory seems quite intolerant to me, opening the parameter check to the programmer is the main reason of this weakness. File access control is too strict that users can only belong to a single group, but it still could not solve the device access control.

As it was said in the chapter that many mechanisms of that Tandem that you can find in today's system succeeded in later on machines. I am as surprised as the author who found Tandem had made such a small impression in the industory. Well, I guess that is not a new story in the history of computer systems that many techniques are not noticed when it's first launched. But I do not agree with the saying that Tandem made a small impression on the design of modern machines, it might not be applied to individual machine, but the whole architecture and idea of fault tolerance can be seen in many places in today's systems.

Beautiful Architecture Ch7.

2009-09-16T18:15:00.000-07:00

Before Xen, the biggest challenge of virtualization is the priviliged instructions that will cause malfunctioning of the operating system. Xen extends the paravirtulization that change the code in operating system to make it compatible in the virtual machine environment. By using mechanisms such as hypercall and virtual memory, Xen is able to share the the memory and run several virtual machines on one physical machine.

Domain zero is a special domain the hypervisor lauches when machine boots up to allocate memory, manage admission.

By applying emulated BIOS and hardware devices, Xen is able to support the hardware virtual machine. And it is because of the open feature of Xen, engineers from AMD and Intel can help on this. IOMMU is a new feature which helps developers to manage the IO devices. It also stops unauthorized memory access.

Pipes and Filters

2009-09-14T17:02:00.000-07:00

As the first architectural pattern, Pipes and Filters is widely used in many systems, I think it is everywhere. But the concept is really big and abstract, I almost don't recognize it when I just read through the chapter without going online and search around for some examples. The most direct use that I came across recently is the IEnumerable approach and a lot of workflow applications. I think the liability is surely exists when you basically need everything in the process of the data flow.

I think passive filters are good when the previous data sources are in a more priority position than the rest of flow, since other part of the system can still process it's own procedure until the data source gets the data ready and send command to them. While as the active mode, the previous sources are fully occupied, only will serve the following sources when needed.

Beautiful Architecture Ch 6.

2009-09-13T19:03:00.000-07:00

The auther gives a detailed introduction of how facebook works out. Facebook provides third party applications to integrate many web services such as SSO, privacy protection and most important to those applications, a network of users that might interested in their web services because the group of friends might share some common interests when they see their friend using some "cool" applications. I think that is quite smart and take good advantage of the social network.

I think one of the reasons that facebook opens itself to other applications is because if depending on Facebook itself, it is really hard to develop such a full amount of variaties of applications and it's really a burden to maintain those applications by its own. An open service interface can let Facebook be a cool place with so many applications without worrying about maintenance, it is a very smart business move. Yet to mention that the company still hold the most important business source, the customer information, actually, a customer network.

FQL, similar to Microsoft .Net LINQ, is a wrapper around internal SQL statement, with this wrapper, the platform maintains its encapsulation and can realize the optimization of query with the minimum impacts on applications.

Facebook gets control on those third party applications by wraping the contents from other sites using iframe, like a sandbox. Also Facebook provides specific markup to render the third party pages in its trusted server environment to let user data have the capability to leave the Facebook domain. And that is FBML. Through FBML, Facebook enables third party pages without hurting the privacy constraint.

I don't think the FBJS as the fair compromise to javascript, since Facebook uses it's own data manipulating language, own page rendering language, but there is weak support for client-side sciprt. But Facebook surely want to put those scripts into a sandbox too, to set boundary and keep consistant in the use of scripting in consider of security and privacy. That is a policy of "you can use the script, but you need to follow my instruction".

I think what Facebook has done makes a good example of proper handling the need for social networking and the issues arised in privacy and security. It provides a comparatively safe and scalable environment for online computing. I think Facebook is a successful example for other web service providers, technically and commercially.

Excerpts from Christopher Alexander

2009-09-10T07:51:00.000-07:00

I think a pattern language, like every other languages, is a way to communicate, to describe a thing with abstraction. It has the elements that the pattern is about, most repeatly using elements or we want to identify from we will give a name. It has a rule to follow, a logic sometimes implicit or explicit. It has a understanding prerequisite to stand above, like the sentence "The tree stands on a hill", when we use it, we are having certain knowlege of it that it won't come out like "The hill stands on a tree". The pattern languages are important to avoid those kind of misunderstanding to happen.

We have seen a lot of patterns in buildings, especially when you travel along in a vast piece of land, you can feel the dramatical changes in the buildings over different places, but they are somewhat related though. As a matter of fact, some of the patterns are so famous that people use it to other areas, like Baroque style is used in other forms of arts like music.

As the "timeless" pattern, I think everything is changing, only the most classical ones will have a longer life span, but it does not mean they are timeless. They can become a classic in the history and maybe are forgotten by people. But some day, somebody will apply that or change that to fits the time,the patterns are back to life with or without the same name. So I think there is not necessary for pattern to be timeless, it's been a great appreciation that they can fit the most requirement now.

Beautiful Architecture Ch 5.

2009-09-09T20:08:00.000-07:00

In this Chapter, the auther discussed a very interesting idea to cache the data using an resource-oriented approach. And this structure that can be accumulatively built and transparent to the user could be really powerful as far as I see, once used rightly. There are enough examples of the techniques turning into a mess because of misuse. And I think the REST service naming convention/method can be one of the many in this techniques that are mistakenly used. So restrict to only 4 verbs might mitigate that risk of misuse or confusions if users can create their own verbs like GET,RETRIEVE,FETCH.... I just think that could be a disaster.

As the auther said in this Chapter, putting data in the forefront is ideally the most intuitive way to send a command, but it might hurts the security. Well, I believe there are some methods to protect the data, but since sometimes, those small queries that contain the most important message are likely to be the attacking target and since their structure are much simpler and they are much shorter than the blob data and they are repeatly appears in the query, such as SSN=... they are in higher risks being sniffed and hacked.

Beautiful Architecture Ch 4.

2009-09-09T17:59:00.000-07:00

In this chapter, the author describes a system that contains many components from different areas, web interface, database, workflow, other automation stations. It used many common now rather standard solutions such as the three layer structure for web applications, repositories for historical image storage, unit testing, database migration. I think they are pretty common in a middle sized web application we see today.

It is interesting that they adapt the incremental architecture which is normally the way things work out for me, but I never think it as such a thing that should be kept doing. There was a colleague in my team who always had the best idea, best approach even sometimes, but turned out nothing at the end. The problem was that he was too worried about some tiny little part of the system was not ready, not perfect yet while majority of the system should already be in the production line. I think the total think-through is important, but things, most of the time, troubles or bugs were not appeared at the first place would eventually be seen in the process. So fail early, fail loudly is good at the end.

Beautiful Architecture Ch 3.

2009-09-09T16:29:00.000-07:00

I think one of the reason that Darkstar does not seem to tied to games closely is because there is lack of benchmarks for large scaled games, no as far as I know of. And that is one of the reasons that before those games are actually go to the shelf, they will provide some public test chances. Gamers get the games to play and the companies get the running data about how the size of the players can be, win win situation. So to prepare for this non-prepared or less prepared situation, they need to find out a more of "having everything prepared" system, a balanced system for all kinds of "in case of", work loads, parallelism, latency, backup plans.

I, myself is not a fan of those online games, but I guess that is a hot spot because I keep seeing all kinds of online games ads flying all over the internet. Sometimes I wondered how can they survive from such intense competitions and still make profit? But I guess they do, since although a lot of the games are vanished quickly, there are still tons of them emerge everyday.

Beautiful Architecture Ch 2.

2009-09-09T15:53:00.000-07:00

It's a very interesting chapter to read through, vivid example about the Messy Metropolis. I was cracking up when I read "The code had grown organically over a period of years", it reminded me about those spaghetti codes that I wrote when I first started coding. Not saying they are perfectly elegent and neat now, but definitely going that way.

I'm strongly agree that tight coupling leads to code that is not able to throughly test. I remembered once I liked to encapsulate the data access code within each function call that need data exchange, well, like every mistake has an excuse, my excuse was that I was running out of time. But year after year, I just let that code sitting there and more and more messy code gets dumped in, until one day, a little error caused me three days to debug that I found out that piece of code needs a overhaul. The result was very good, at least I could run small test cases module by module.

I experienced both sides of the system, and what I have learned is keeping a good pace in development and refector in timely manner is important. You don't want the development to be too rushy that cause bugs or taking too long. It is a pain to working on millions of things parallelly but get nothing done. No output after a certain time can be a warning. Refectoring is another important thing to do to make sure the code are clean and still makes sense.

I hope I could always be in the nice side of the system, but being in bad side makes me aware all those ugly things and learn how to deal with them.

Beautiful Architecture Ch1.

2009-09-08T19:45:00.000-07:00

I wondered why I did not ever link the software architecture to the buildings, well, I definitely used the terms such as hierarchy and of course, architecture. But the similarity between building construction and software development did not seem to be so close to me before reading Chapter 1.

So, like buildings that some are wonderful, some are special, some are just so so, you can tell the quality differences between architectures of softwares. Other than the concerns on aspects of software in Table 1-1 in the book, I think as a developer, there is an intuitive feeling about the architecture of a system. Simple, easy to understand, easy to use, clever and thoughtful designs, structured but flexible... I think this book will let me find other beautiful spot of a system.

ArchJava

2009-09-07T08:27:00.000-07:00

It is a very interesting paper from a software architecture point of view, applying a structure to ensure the implementation conforms to communication integrity. It adds constructs such as components, connections and ports to enforce the communication integrity. In this paper, a middle-sized program that runs on a single JVM is converted into ArchJava architecture.

Actually, I found the evaluation process and analysis process effective. It answers the questions in my mind when I read the section 1-3. But it also make many assumptions/hypothesis during the evaluation process, which will be a case by case basis according to different applications that might not be reusable in other applications.

As it is said in the paper that ArchJava is suitable for middle-sized applications that run on single machines, I think it can have some use in application development.

"4+1" view

2009-09-02T19:08:00.000-07:00

I still remember the very first project that I did when I just graduated from college, my boss wanted a proposal on a big project for a university. I don't know why she would ever willing to put that kind of work to the hands of a just-graduated, maybe we were short of people at that moment. It was not a happy experience, suddenly I found what I learned in college was just text books, not enough for me to tackle questions like what is the proper capacity servers we should order, or things like what are the interfaces between applications we need to consider for possible future extensions. It will take an experienced system architecture some time to sort all that kind of things out, not to mention to the poor non-experienced me. Anyway, I wish I saw this article 7 years ago at that time. Because the chart that I made in that proposal was harshly criticized by the project committee. Well, I had to admit that putting all sorts of information on one tiny little diagram was not a smart choice, because I had to explain where the server means hardwares, where it means middlewares, where it means applications, for example DBMS. I could find excuses for myself that we could not have detailed design until we start the project. But my system "pre-design" diagrams could not find excuses by themselves that they are really mashed up with mixed concepts and very confusing. Everyone has their own interpretation, it might have caused turmoil when we started the project. Lucky for us that we PMed that project too, so as long as our team was on one page, everything was working out. So I really appreciate the "4+1" view concepts in this article and I think that is very realistic too.

2009-08-27T20:02:00.000-07:00

Test post for planet