RSS feed [root] /design /weblog




login:

password:

title search:




 


Thu May 23 22:45:24 HKT 2019

design



(google search) (amazon search)
second
download zip of files only

Sun Oct 11 21:31:07 HKT 2020 From /weblog/design

DataStructure


"Bad programmers worry about the code. Good programmers worry about data structures and their relationships." - http://programmers.stackexchange.com[..]uote-about-good-programmer/163187#163187

Compare between schema and schema=less ( like key value mapping ) data - http://martinfowler.com/articles/schemaless/

Simple AVL tree - https://www.baeldung.com/java-avl-trees

逼着面试官问了我 ArrayList 和 LinkedList 的区别,他对我彻底服了 - https://xie.infoq.cn/article/34fa38d821b065e26662e6598

(google search) (amazon search)


Sun Oct 11 19:44:53 HKT 2020 From /weblog/design

messaging


Why should you combine Reliable Messaging with Distributed Caching - http://www.theserverside.com[..]MessagingDistributedCaching/article.html

Read from cache, write the message system - http://radio.weblogs.com/0112098/2003/01/15.html#a319

All You Need to Know About ActiveMQ - https://itnext.io/all-you-need-to-know-about-activemq-76edb977e6a

(google search) (amazon search)


Sat Sep 26 23:09:02 HKT 2020 From /weblog/design

performance


http://highscalability.com[..]6/big-list-of-20-common-bottlenecks.html

Nothing specific, mostly code clean up, refactoring and simplification, the performance boost was a surprise. <- This is a good one - http://bad-concurrency.blogspot.com.au[..]12/07/disruptor-v3-faster-hopefully.html

Is there anything we can do about this when designing algorithms and data-structures? Yes there is a lot we can do. If we perform chunks of work on data that is co-located, and we stride around memory in a predictable fashion, then our algorithms can be many times faster. For example rather than using bucket and chain hash tables, like in the JDK, we can employ hash tables using open-addressing with linear-probing. Rather than using linked-lists or trees with single items in each node, we can store an array of many items in each node. - http://mechanical-sympathy.blogspot.com.au[..]emory-access-patterns-are-important.html

Skip lists are used instead of b-trees because b-trees don’t scale. - http://highscalability.com[..]ast-mvcc-inmem-lockfree-codegen-and.html

Beware about the performance issue of static initalization - http://stackoverflow.com[..]-cause-problems-with-multi-threading-how

Experiment show why arraylist is better in most cases - http://www.javaadvent.com/2013/12/arraylist-vs-linkedlist.html

How to design low latency application in java - http://vanillajava.blogspot.com.au[..]5/chronicle-and-low-latency-in-java.html

http://highscalability.com[..]ciples-of-high-performance-programs.html http://blog.libtorrent.org[..]principles-of-high-performance-programs/

Suggestion about how to determine number of thread pool - http://venkateshcm.com[..]rmine-Web-Applications-Thread-Poll-Size/

Beware the performance penalty of logging - https://plumbr.eu/blog/locking-and-logging

Keep thing dynamic - http://highscalability.com[..]ciples-of-high-performance-programs.html

http://www.rationaljava.com[..]st-rule-of-performance-optimisation.html

http://www.eecs.berkeley.edu[..]u/~rcs/research/interactive_latency.html

http://highscalability.com[..]aling-data-platforms.html?SSLoginOk=true

Discuss about developing low latency financial application - http://queue.acm.org/detail.cfm?ref=rss&id=2770868

Discussion of object pooling - http://highscalability.com[..]-but-forgotten-trick-object-pooling.html http://coffeenco.de[..]m_performance_part_1_object_pooling.html

Efficiency - the amount of work you need to do.
Performance - how fast you can do that work
Efficiency - governed by your algorithm
Performance - governed by your data structures.
http://www.rationaljava.com[..]e-difference-between-efficiency-and.html


Turning off power save mode on the CPU reduced brought the max latency from 11 msec down to 8 msec.
Guaranteeing threads will always have CPU resources using CPU isolation and thread affinity brought the maximum latency down to 14 microseconds.
http://highscalability.com[..]eduler-jitter-using-cpu-isolation-a.html
http://epickrram.blogspot.co.uk[..]o.uk/2015/09/reducing-system-jitter.html

About design for performance for webapi - http://tech.forter.com[..]y-decision-as-a-service-design-patterns/

check list - http://techbeacon.com[..]ery-software-development-team-should-ask

Beware if system utilization over 80% - http://www.infoq.com/cn/news/2016/02/utilisation-wait-latency http://robharrop.github.io[..]/20/service-latency-and-utilisation.html

scalable-io-events-vs-multithreading-based - https://thetechsolo.wordpress.com[..]lable-io-events-vs-multithreading-based/

How to find out bottleneck - https://vanilla-java.github.io[..]entile-latencies-in-Chronicle-Queue.html

https://www.inkandswitch.com/slow-software.html

Compiler Performance and LLVM - http://pling.jondgoodwin.com/post/compiler-performance/

Know Thy Complexities! - https://www.bigocheatsheet.com[..]oW9D2qyCTt3qMftzYxsdz7KJs8LkSeRPWLzguwpA

10 大高性能开发宝石 - https://xie.infoq.cn/article/a0d418bf29915ecad5d5eeab0

(google search) (amazon search)


Sun Sep 20 22:10:28 HKT 2020 From /weblog/design

cache


5 Hints You're Using A Map When You Should Be Using a Cache? - http://dsoguy.blogspot.com[..]ints-your-using-map-when-you-should.html

How hibernate design the cache - http://www.javalobby.org/java/forums/t48846.html

Consider to do more careful update, not just update DB and dirty cache, but update DB and cache in a same time - http://dormando.livejournal.com/495593.html

Caching can be architectural smell, some hint and some alternative - http://www.codingthearchitecture.com[..]2/is_caching_an_architectural_smell.html

General caching discussion - http://tutorials.jenkov.com[..]are-architecture/caching-techniques.html http://www.infoq.com/cn/news/2017/01/Program-design-how-cache

http://highscalability.com[..]10-program-busting-caching-mistakes.html http://www.codeproject.com[..]B/web-cache/cachingmistakes.aspx?azid=74

缓存穿透?击穿?雪崩? - https://xie.infoq.cn/article/39495c2d568aca1d6db5c9c50?y=qun0918

(google search) (amazon search)


Mon Sep 14 09:23:51 HKT 2020 From /weblog/design

logging


http://www.codemonkeyism.com[..]08/12/16/7-good-rules-to-log-exceptions/ - look obvious but a lot of program still make those mistakes.

Do you prefer log more or log smarter? It is good to log smart but if you log more, even if you not smart enough, you still have the data. - http://www.codinghorror.com/blog/archives/001192.html

Basic log techniques - http://www.ddj.com/cpp/212902973?cid=RSSfeed_DDJ_All

Advances and Challenges in Log Analysis - http://queue.acm.org/detail.cfm?id=2082137&ref=fullrss

Filtering only useful stacktrace - http://www.javacodegeeks.com[..]ter-irrelevant-stack-trace-lines-in.html

Some suggestion about logging - http://www.javacodegeeks.com[..]/10-tips-proper-application-logging.html and http://googletesting.blogspot.com.au/2013/06/optimal-logging.html

9 Logging Sins in Your Java Applications, the "Logging Plain User Input" is a good one - https://dzone.com[..]9-logging-sins-in-your-java-applications

Java Logging Best Practices: 10+ Tips You Should Know to Get the Most Out of Your Logs - https://sematext.com/blog/java-logging-best-practices/

(google search) (amazon search)


Fri Aug 21 21:54:46 HKT 2020 From /weblog/design

API design guideline


This is a message from a management blog, but I think the arguement is also apply API design. In fact, I think most critical difference of good and bad API is knowing which small detail is important and which is not - http://www.goodproductmanager.com[..]er.com/2007/11/08/sweat-the-small-stuff/

Design tips:
http://www.artima.com/weblogs/viewpost.jsp?thread=142428
http://openide.netbeans.org/tutorial/api-design.html
http://www.cincomsmalltalk.com[..]gView?showComments=true&entry=3258158706
http://today.java.net[..]its-of-highly-profitable-developers.html
http://www.infoq.com/news/2007/08/why-api-design-matters
http://www.infoq.com/presentations/effective-api-design
http://neuroning.com/2006/11/19/on-api-design-guidelines

About Compatibility issues
http://wiki.eclipse.org/Evolving_Java-based_APIs

A blog of using interfaces-vs-abstract-classes
http://hoskinator.blogspot.com[..]6/04/interfaces-vs-abstract-classes.html

XOM design overview - http://www.xom.nu/designprinciples.xhtml#d0e309

You need to identify the business value but not pick any tools/design just because it is cool - http://myarch.com/what-is-good-soa

A lot of links here - http://kasparov.skife.org/blog-live/src/api-design-refs.writeback http://discuss.joelonsoftware.com/default.asp?design.4.527465

An introduction of good OSS project to study their source - http://techkriti.wordpress.com[..]com/2007/06/28/learning-from-the-source/

CCCCDPIPE - http://blog.objectmentor.com/articles/2007/08/02/which-came-first

Discussion of why getting feedback quick is important - http://blog.objectmentor.com[..]u-dont-know-until-you-take-the-next-step

Someone saying that routines is the greatest invention in CS, I agree - http://www.codinghorror.com/blog/archives/001129.html

New way of modeling system then layering, The Onion Architecture - http://jeffreypalermo.com/blog/the-onion-architecture-part-1/

SOLID - http://www.lostechies.com[..]of-the-month-march-solid-principles.aspx http://dotnet.dzone.com/news/solid-software-works <-- very good picture! http://www.blackwasp.co.uk/SOLIDPrinciples.aspx https://www.freecodecamp.org[..]d-principles-explained-in-plain-english/

Idempotent, Orthogonality, Immutability - http://www.codinghorror.com/blog/archives/001244.html

Some example of how to driven good API - http://jdegoes.squarespace.com[..]al/2009/5/11/good-api-design-part-3.html

It's not enough to write tests for an API you develop, you have to write unit tests for code that uses your API. When you do, you learn first-hand the hurdles that your users will have to overcome when they try to test their code independently. http://butunclebob.com[..]MichaelFeathers.TheGoldenRuleOfApiDesign

Active interface vs. Passive interface, for me this is another way to under "Tell, don't ask" - http://code-o-matic.blogspot.com[..]-on-api-design-call-stack-as-source.html

The Principles of Good Programming - http://www.artima.com/weblogs/viewpost.jsp?thread=331531

http://net.tutsplus.com[..]software-principles-you-must-understand/

Difference choice of how API evolute with change - http://blog.jooq.org[..]sive-api-evolution-with-java-interfaces/

JUnit's evolving structure. - http://edmundkirwan.com/general/junit.html

API performance contract - http://queue.acm.org/detail.cfm?ref=rss&id=2576968

Consistent naming conventions
Standard terminology
Uniform error responses
Attention to detail (that’s the love part for APIs)
REST APIs that work with only 2 resources and use 4 HTTP verbs (oh, there is so much more to talk about here…)
Avoid API design by way of method-driven approach – that leads you down a slippery slope
- See more at: http://blogs.ancestry.com[..]are-like-parenting/#sthash.Ux1LHMNU.dpuf

http://blog.jooq.org[..]ake-this-mistake-when-developing-an-spi/

Guideline for webapi - https://cloud.google.com/apis/design/

Good naming is part of design. It sets expectations and communicates a model, showing how something should be understood and used. If you mean to tell the reader getMillisSince1970, don’t say getTime. Specific names inspire you to consider alternatives, to question whether you’re capturing the right abstraction in the right way. It’s not just labeling and it’s not just java.util.Date: This is about the code you write and the code you use. - https://medium.com/97-things/name-the-date-c82bafdc4c44

(google search) (amazon search)


Mon Jul 27 08:24:34 HKT 2020 From /weblog/design/examples

bbc


https://www.infoq.com[..]/bbc-distributed-monolith-microservices/

(google search) (amazon search)


Fri Jul 24 21:50:06 HKT 2020 From /weblog/design/examples

mailinator


https://manybrain.github.io/m8r_blog/blog/mailinator-evolution/

(google search) (amazon search)


Fri Jul 03 08:56:19 HKT 2020 From /weblog/design/distribute

cloud


1. Use Cloud for Scaling
2. Use Cloud for Multi-tenancy
3. Use Cloud for Batch processing
4. Use Cloud for Storage
5. Use Cloud for Communication

http://horicky.blogspot.com/2009/11/cloud-computing-patterns.html

http://horicky.blogspot.com/2009/11/nosql-patterns.html

Database in cloud - http://drdobbs.com[..]int?articleId=218900502&siteSectionName=

An overview of the Hadoop/MapReduce/HBase framework and its current applications in bioinformatics - http://www.biomedcentral.com/1471-2105/11/S12/S1

The architecture that survived when amazon outage - http://www.infoq.com/news/2011/04/twilio-cloud-architecture

Introduction of few tools for cloud development - http://blog.codecentric.de[..]/01/best-development-tools-in-the-cloud/ http://www.javacodegeeks.com[..]/07/developing-and-testing-in-cloud.html

Google Finds: Centralized Control, Distributed Data Architectures Work Better than Fully Decentralized Architectures - http://highscalability.com[..]control-distributed-data-architectu.html

https://www.thoughtworks.com[..]ticles/understanding-clouds-significance

(google search) (amazon search)


Tue Jun 02 08:23:00 HKT 2020 From /weblog/design

Implementation


Tired with duplicating Try-Catch for resource acquisition? Can try to create proxy method - http://hamletdarcy.blogspot.com[..]clarative-synchronization-with-java.html

Discussion of naming of if block - http://blog.objectmentor.com/articles/2008/09/26/if-methods-redux

Factors for choosing a strategic technology stack, runtime performance is not a factor for him, probably good idea - http://jchyip.blogspot.com[..]1/04/factors-for-choosing-strategic.html

Don't think , stay focus - http://www.threeriversinstitute.org/blog/?p=594

Using class name as variable name is a bad thing? I doubt about it, but interesting idea - http://www.warski.org/blog/2013/01/dry-parameter-names/

The problem of using generic name - http://martinfowler.com/bliki/TransparentCompilation.html

Beware of where memory allocated, sometime there is no off side for lazy initalization - http://plumbr.eu[..]ou-dare-to-change-hashmap-implementation

Some suggestion of how to code in order to prevent unreproducible bugs - http://googletesting.blogspot.hk[..]4/02/minimizing-unreproducible-bugs.html

More careful to check null - http://blog.jooq.org[..]et-paranoid-java-programming-techniques/

http://www.infoq.com/cn/articles/wisdom-of-programming

The fewer conditions you test for, the better your code “tastes”. - https://medium.com[..]ding-requirement-99749f37684a#.1glkhe7np

Think twice before running a loop - https://blog.jetbrains.com/idea/2017/08/code-smells-iteration

Example of how to remove mutation status - https://blog.jetbrains.com/idea/2017/08/code-smells-mutation

The Best Algorithm No One Knows About, linear randomization - https://getkerf.wordpress.com[..]0/the-best-algorithm-no-one-knows-about/

Small change can make big difference - https://blog.pitest.org[..]ars-with-a-single-character-code-change/

Eager is Easy, Lazy is Labyrinthine - https://medium.com[..]s-easy-lazy-is-labyrinthine-b12605f13048

(google search) (amazon search)


Sat May 23 12:22:23 HKT 2020 From /weblog/design

refactoring


http://c2.com/cgi/wiki?RefactoringLanguage

Refactoring to Patterns Catalog - http://www.industriallogic.com/xp/refactoring/catalog.html

Article talk about the book: http://www.oreillynet.com/ruby/blog/2006/03/transformation.html

Catagories smell into "smell in class" and "smell between class" - http://www.codinghorror.com/blog/archives/000589.html

Known but good to remind http://www.thecodejunkie.com[..]10/01/6-steps-to-master-refactoring.html

An experience sharing - http://www.javacodegeeks.com[..]m/2011/05/refactor-hudson-god-class.html http://www.peterprovost.org[..]treme-Refactoring-with-Brian-Button.aspx

Refactoring should not introduce bug... - http://jchyip.blogspot.com[..]01/so-why-are-you-refactoring-again.html

A way to have formal refactoring, through Feature Clustering, Rapid Scratch Refactoring and Twisting Classes - http://www.thekua.com[..]rom-michael-feathers-brutal-refactoring/

Not all code change is refactoring - http://parlezuml.com/blog/?postid=850 , and

Some common issues about refactoring code in a team - http://www.rickylui.com[..]/2008/01/28/dont-be-a-refactoring-bigot/ http://blog.joepoon.com[..]01/dangers-of-premature-refactoring.html , beware taking the balance - http://www.makinggoodsoftware.com[..]ith-beautiful-code-the-refactor-syndrome

Refactory if needed - http://dreamhead.blogbus.com/logs/24874404.html

Refactoring, when start, when stop? - http://martinfowler.com/bliki/OpportunisticRefactoring.html

Refactoring metric - http://www.grahambrooks.com[..]rics-based-refactoring-for-cleaner-code/

Getting rid of util class
1) If the family of methods uses different parameters, depending on optional input or representations of the same input, then consider transforming the Helper via a fluent interface using the Builder pattern: from a collection of static methods like Helper.calculate(x), calculate(x, y), calculate(x, z), calculate(y, z) we could easily get to something like newBuilder().with(x).with(y).calculate(). The helper class would then offer behaviours, reduce its list of business methods and provide more flexibility for future extensions. Callers would then use it as internal field for reuse or instantiate it where needed. The helper class (as we knew it) disappeared.
2) If the helper class provides methods which are actually actions for different inputs (but, at this point, for the same domain), consider applying the Command pattern: the caller will actually create the required command (which will handle the necessary input and offer a behaviour) and an invoker will execute it within a certain context. You may get a command implementation for each static method and your code would move from an Helper.calculate(x, y), calculate(z) to something like invoker.calculate(new Action(x, y)). Bye bye helper class.
3) If the helper class provides methods for the same input but different logics, consider applying the Strategy pattern: each static method may easily become a strategy implementation, vanishing the need of its original helper class (replaced by a context component then).
4) If the given set of static methods concerns a certain class hierarchy or a defined collection of components, then consider applying the Visitor pattern: you may get several visitor implementations providing different visit methods which would probably replace partially or entirely the previously existing static methods.
5) If none of the above cases met your criteria, then apply the three most important indicators: your experience, your competences in the given project and common sense.

http://www.refactoringideas.com[..]-to-get-rid-of-helper-and-utils-classes/

Converting forloop to streaming - http://martinfowler.com/articles/refactoring-pipelines.html

Refactoring JavaScript from Sync to Async in Safe Baby-Steps - http://www.natpryce.com/articles/000812.html

code-refactoring-dos-donts - https://jaxenter.com/code-refactoring-dos-donts-135960.html

Let clean code guide you. Then let it go. - https://overreacted.io/goodbye-clean-code/ https://www.infoq.cn/article/dNO484YEeumvC6b6ZNWL

https://martinfowler.com/articles/class-too-large.html

(google search) (amazon search)


Sun May 17 01:10:13 HKT 2020 From /weblog/design/examples

zoom


http://highscalability.com[..]2020/5/14/a-short-on-how-zoom-works.html

(google search) (amazon search)


Thu May 07 20:31:36 HKT 2020 From /weblog/design/distribute

event


Event Bus Implementation(s) - https://hackernoon.com/event-bus-implementation-s-d2854a9fafd5 http://www.infoq.com[..]2017/08/Summary-event-bus-implementation

http://jakewharton.com/managing-the-reactive-world-with-rxjava/

6 Event-Driven Architecture Patterns — https://medium.com[..]rchitecture-patterns-part-1-93758b253f47

(google search) (amazon search)


Sat Mar 28 20:09:46 HKT 2020 From /weblog/design/distribute

scalability


There are two key primary ways of scaling web applications which is in practice today.
1) “Vertical Scalability” - Adding resource within the same logical unit to increase capacity. An example of this would be to add CPUs to an existing server, or expanding storage by adding hard drive on an existing RAID/SAN storage.
2) “Horizontal Scalability” - Adding multiple logical units of resources and making them work as a single unit. Most clustering solutions, distributed file systems, load-balancers help you with horizontal scalability.

Scalability can be further sub-classified based on the “scalability factor”.
1) If the scalability factor stays constant as you scale. This is called “linear scalability“.
2) But chances are that some components may not scale as well as others. A scalability factor below 1.0 is called “sub-linear scalability“.
3) Though rare, its possible to get better performance (scalability factor) just by adding more components (i/o across multiple disk spindles in a RAID gets better with more spindles). This is called “supra-linear scalability“.
4) If the application is not designed for scalability, its possible that things can actually get worse as it scales. This is called “negative scalability“.

http://www.royans.net/arch/2007/09/22/what-is-scalability/

Report of building web application with 55k pageload with rail - http://shanti.railsblog.com[..]mongrels-handled-a-550k-pageview-digging

XMPP a IM protocol about scalability - http://www.process-one.net[..]icle/the_aol_xmpp_scalability_challenge/

Presentation and resources of making you website more scalable - http://www.scribd.com[..]9/Real-World-Web-Performance-Scalability http://www.theserverside.com[..]lications&asrc=EM_NLN_3990118&uid=703565 http://www.theserverside.com[..]ionsPart2&asrc=EM_NLN_3990119&uid=703565

Brian Zimmer, architect at travel startup Yapta, highlights some worst practices jeopardizing the growth and scalability of a system:
* The Golden Hammer. Forcing a particular technology to work in ways it was not intended is sometimes counter-productive. Using a database to store key-value pairs is one example. Another example is using threads to program for concurrency.
* Resource Abuse. Manage the availability of shared resources because when they fail, by definition, their failure is experienced pervasively rather than in isolation. For example, connection management to the database through a thread pool.
* Big Ball of Mud. Failure to manage dependencies inhibits agility and scalability.
* Everything or Something. In both code and application dependency management, the worst practice is not understanding the relationships and formulating a model to facilitate their management. Failure to enforce diligent control is a contributing scalability inhibiter.
* Forgetting to check the time. To properly scale a system it is imperative to manage the time alloted for requests to be handled.
* Hero Pattern. One popular solution to the operation issue is a Hero who can and often will manage the bulk of the operational needs. For a large system of many components this approach does not scale, yet it is one of the most frequently-deployed solutions.
* Not automating. A system too dependent on human intervention, frequently the result of having a Hero, is dangerously exposed to issues of reproducibility and hit-by-a-bus syndrome.
* Monitoring. Monitoring, like testing, is often one of the first items sacrificed when time is tight.

http://highscalability.com/scalability-worst-practices

Useful Corporate Blogs that Talk About Scalability - http://highscalability.com[..]l-corporate-blogs-talk-about-scalability

Overview of mapreduce and how it compare with other distributed programming model -http://natishalom.typepad.com[..]0/is-mapreduce-going-to-main-stream.html

Paper of data store at amazon http://www.allthingsdistributed.com/2007/10/amazons_dynamo.html

Discuss how haven't sync can cause performance issue - http://www.theserverside.com[..]lications&asrc=EM_NLN_6273194&uid=703565 http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6423457

Discussion about Cloud Based Memory Architectures - http://highscalability.com[..]ased-memory-architectures-next-big-thing

http://highscalability.com[..]alability-and-performance-best-practices

Interview with google engineer - http://www.zdnet.co.uk[..]gle-at-scale-everything-breaks-40093061/

Surprisingly youtube is blocking - http://highscalability.com[..]e-scalability-lessons-in-30-minutes.html

If we are seeing a sustained arrival rate of requests, greater than our system is capable of processing, then something has to give. Having the entire system degrade is not the ideal service we want to give our customers. A better approach would be to process transactions at our systems maximum possible throughput rate, while maintaining a good response time, and rejecting requests above this arrival rate. - http://mechanical-sympathy.blogspot.com.au[..]apply-back-pressure-when-overloaded.html

How twitter scaling - http://www.infoq.com/presentations/Twitter-Analytics

How Reddit scaling - http://www.infoq.com/presentations/scaling-reddit

How Hotjar scaling - https://www.hotjar.com[..]-while-scaling-hotjars-tech-architecture

How infiniteDB prevent locking and IO - http://highscalability.com[..]-scalable-relational-database-manag.html

http://highscalability.com[..]ard-way-about-scaling-a-million-use.html http://martin.kleppmann.com[..]2014/03/26/six-things-about-scaling.html

The experiences of various big companies, about network issues - http://aphyr.com/posts/288-the-network-is-reliable

Stackoverflow, scale without cloud - http://highscalability.com[..]nth-25-servers-and-i.html?SSLoginOk=true

How netflix scale - http://highscalability.com[..]ix-what-happens-when-you-press-play.html

Scaling to 100k Users - https://alexpareto.com[..]ity/systems/2020/02/03/scaling-100k.html https://www.infoq.cn/article/Tyx5HwaD9OKNX4xzFaFo

(google search) (amazon search)


Mon Mar 16 07:47:36 HKT 2020 From /weblog/design

Object attributes


About getter and setter - http://blog.milesbarr.com/2006/09/getters-and-setters/

Discussion of hashcode and equal of collections - http://redsolo.blogspot.com[..]11/why-no-equals-and-gethashcode-in.html

A blog discuss the problem of getter / setter - http://jroller.com[..]rise?entry=the_case_against_the_property

Equality Is Hard - https://www.craigstuntz.com[..]m/posts/2020-03-09-equality-is-hard.html

(google search) (amazon search)


Wed Mar 04 08:23:59 HKT 2020 From /weblog/design

functional


Having functional program in java? http://codemonkeyism.com/functional-programming/

Functional programming in old java, with eclipse template - http://www.javacodegeeks.com[..]functional-programming-with-map-and.html

Functional Programming For The Rest of Us - http://www.defmacro.org/ramblings/fp.html?

collection-pipeline - http://martinfowler.com/articles/collection-pipeline/

Make code composable - https://hackernoon.com[..]ical-functional-programming-6d7932abc58b

A primer on functional architecture - https://increment.com[..]cture/primer-on-functional-architecture/

(google search) (amazon search)


Sat Nov 16 20:30:12 HKT 2019 From /weblog/design/examples

web


https://codurance.com[..]ites-using-finite-state-machines-part-I/

(google search) (amazon search)


Fri Sep 06 20:54:59 HKT 2019 From /weblog/design/examples

Serialization


What serialization is bad - http://cr.openjdk.java.net/~briangoetz/amber/serialization.html

(google search) (amazon search)



Sat Jun 22 09:23:22 HKT 2019 From /weblog/design

microservice


The Hidden Dividends of Microservices - http://queue.acm.org/detail.cfm?ref=rss&id=2956643

Best practices - http://www.infoq.com[..]constructing-micro-service-system-part03

http://basho.com/posts/technical/microservices-please-dont/

Compare using library / service - http://blog.jessitron.com/2017/01/dependencies.html http://www.infoq.com[..]cy-management-whether-library-or-service

What We Got Wrong: Lessons from the Birth of Microservices - https://www.infoq.com/presentations/google-microservices/ https://www.infoq.cn/article/L*bT1UfuVoj1I6NRNM3U

(google search) (amazon search)


Thu May 23 22:45:47 HKT 2019 From /weblog/design

camera


軟體相機時代來臨!Google Pixel 工程師來台揭秘相機技術 - https://www.inside.com.tw[..]cle/16465-google-pixel-camera-background

(google search) (amazon search)


Mon May 13 16:23:25 HKT 2019 From /weblog/design

Architecture


Top Ten Software Architecture Mistakes - http://www.infoq.com/news/2007/10/top-ten-architecture-mistakes

Discussion about the balance of upfront design - http://blog.objectmentor.com[..]4/25/the-scatology-of-agile-architecture

There is no conflict in agile and architecture - http://www.andrejkoelewijn.com[..]s-no-conflict-in-agile-and-architecture/

http://c2.com/cgi/wiki?HexagonalArchitecture

Experience of build instead of buy - http://arstechnica.com[..]uy-one-companys-decision-to-go-it-alone/

Problem of too many layer - http://johannesbrodwall.com[..]/10/the-madness-of-layered-architecture/

http://edmundkirwan.com/general/simple.html

http://blog.schauderhaft.de[..]are-architect-here-is-your-reading-list/

Sometime it is worth to build to throw - http://martinfowler.com/bliki/SacrificialArchitecture.html

Business Transactions
External Dependencies
Caching Strategy
Garbage Collection
Application Topology
http://blog.appdynamics.com[..]s-to-capture-in-enterprise-applications/

invent a solution the majority of whose components depend on no others with those few components whose task it is to compose those other components being left largely to coordination roles. - http://edmundkirwan.com/general/simple.html

http://blog.cloudera.com[..]ting-started-with-big-data-architecture/

Twitter - http://www.infoq.com/cn/articles/twitter-architecture-evolution http://highscalability.com[..]tter-handles-3000-images-per-second.html

Suning, more on HTTP - http://www.infoq.com[..]oduct-details-system-architecture-design

Decision - https://javax0.wordpress.com/2016/05/04/architects-dont-decide/

Some suggestion of making system simple, well, but the suggestion itself it is that simple - https://www.infoq.com/articles/driving-architectural-simplicity

https://medium.com[..]ural-patterns-in-a-nutshell-a0b47a1e9013

https://www.in28minutes.com/introduction-to-software-architecture

(google search) (amazon search)


Sun Apr 28 00:48:00 HKT 2019 From /weblog/design/distribute

distribute


In one sentence, here's why: humans are notoriously bad at keeping "self" distinct from "other". Egomania, projection (transference), and enmeshment are well-known symptoms of this problem. OK, so I hear you saying, "yeah, but what does this have to do with programming?" It certainly seems absurd to suggest that if we are bad at something we know the most about (our "selves"), how could we possibly say that we have a good approach for the programming analogues - objects, modules, etc. - http://www.artima.com/weblogs/viewpost.jsp?thread=46706

Argue why space base design is better than n-tier design - http://www.google.com[..]0The%20End%20of%20Tier-based%20Computing

Some key research of google for distributed computation - http://www.infoq.com/news/2007/06/google-scalability

Someone think we are not yet (per Oct 2007) have good language support for distibuted computing - http://kasparov.skife.org/blog/2007/10/11/

A blog contain a lot distributed computing information - http://www.highscalability.com/

How Wikipedia manage their site - http://dammit.lt/uc/workbook2007.pdf

Google tutorial for Design Distributed System - http://code.google.com/edu/parallel/dsd-tutorial.html

http://en.wikipedia.org/wiki/Distributed_hash_table

The Hadoop Distributed File System: Architecture and Design - http://hadoop.apache.org/core/docs/r0.18.0/hdfs_design.html

http://www.metabrew.com[..]-a-list-of-distributed-key-value-stores/

Applying experience from CPU design for distributed solution - http://blog.paralleluniverse.co[..]o/post/26909672264/on-distributed-memory

Distributed systems for fun and profit - http://book.mixu.net/distsys/single-page.html

Monitor and design - http://highscalability.com[..]buted-mission-critical-applications.html

Uber case study - http://highscalability.com[..]les-their-real-time-market-platform.html

Load balancer design - http://www.thegeekstuff.com/2016/01/load-balancer-intro/

Some issues of distributing logic to difference systems - http://blog.takipi.com[..]t-f-up-your-microservices-in-production/

https://blog.acolyer.org[..]lised-solution-to-distributed-consensus/

(google search) (amazon search)


Sun Apr 28 00:45:21 HKT 2019 From /weblog/design/examples

messaging


ZeroMQ: The Design of Messaging Middleware - http://www.drdobbs.com[..]&siteSectionName=architecture-and-design

When NOT to use a message queue - http://techblog.bozho.net/?p=1455

现代IM系统中的消息系统架构 - 架构篇 - https://yq.aliyun.com/articles/698301

(google search) (amazon search)


Thu Feb 28 12:47:16 HKT 2019 From /weblog/design/examples

analytic


Experience of using AWS Redshift - http://highscalability.com[..]on-events-a-day-the-shift-to-redshi.html

(google search) (amazon search)