https://medium.com/@zacharykuhn/5-things-i-m-learning-to-level-up-as-a-developer-7b65175c85ea
https://mp.weixin.qq.com/s/DwDzOcQZIK9vd6FQTyuIWQ
https://henrikwarne.com/2015/04/16/lessons-learned-in-software-development/yo
https://henrikwarne.com/2014/12/15/programmer-knowledge/
The sheer joy of making things
The pleasure of making things that are useful to other people
The joy of always learning, which springs from the nonrepeating nature of the task
https://henrikwarne.com/2014/06/30/what-makes-a-good-programmer/
https://henrikwarne.com/2016/04/28/learning-from-your-bugs/
Every time I fix a particularly tricky or interesting bug, I take a few minutes to write down some facts about i
Symptom/Root Cause/How Found/How to Fix/Lessons
https://henrikwarne.com/2017/01/15/book-review-the-effective-engineer/
Developers – Talk To People
So by just discussing for a few minutes, we found a better solution. I think of this as an informal design review, similar to a code review, but done before implementation, not after. I frequently try to discuss a change with a colleague before going ahead and doing it. Time and again I am grateful that I did. Many times we discover flaws, or better solutions, that I would never have thought of, no matter how hard I tried. So with a little bit of discussing, I end up with much better solutions.
https://blog.csdn.net/xiedongsheng/article/details/79721993
1）熟悉更多业务，不管是不是你负责的；熟悉更多代码，不管是不是你写的
https://mp.weixin.qq.com/s/--sD1nrO6A4xcXlRuwgnnA
https://www.yejianye.com/2018/03/04/journaling
https://mp.weixin.qq.com/s/6zVBuQQTepLSXjkLA5qEqA
https://mp.weixin.qq.com/s/4jj26NPCIVfMsAY_M7WH_A
https://mp.weixin.qq.com/s/1NPaMmEVYYBaKrbbAih0RQ
https://github.com/sesamegu/doc/blob/master/一个好码农的八个特质.md
https://bravenewgeek.com/shit-rolls-downhill/
https://www.kitchensoap.com/2012/10/25/on-being-a-senior-engineer
Nothing indicates that you have a lack of perspective and awareness like a poorly thought out and nonconstructive tweet that slings venomous insults. It’s a junior engineer mistake to toss insults about a piece of complex technology in 140 characters.
Ok, let’s work on this together. I can show you how I’m writing/troubleshooting/etc. Then, you do it so I can be sure you know why/how we’re doing it this way, etc
Later on in the lifecycle of a design, when the original design is not scaling anymore or needs to be replaced or rewritten, they can look back not with a perspective of how short-sighted those earlier decisions were, but instead say “yep, we made it this far with it and knew we’d have to extend or change it at some point. Looks like that time is now, let’s get to work!” instead of responding with a cranky-pants, passive-aggressive Hindsight Bias-filled remark with counterfactuals (e.g.. “those idiots didn’t do it right the first time!”, “they cut corners!”, “I TOLD them this wouldn’t work!”)
Dirty secret: mature engineers know the importance of (sometimes irrational) feelings people have. (gasp!)
“It is amazing what you can accomplish if you do not care who gets credit.”
http://muratbuffalo.blogspot.com/2018/02/think-before-you-code.htmlThink before you code
Always think
http://blog.cleancoder.com/uncle-bob/2015/11/18/TheProgrammersOath.html
I will not produce harmful code.
The code that I produce will always be my best work. I will not knowingly allow code that is defective either in behavior or structure to accumulate.
I will produce, with each release, a quick, sure, and repeatable proof that every element of the code works as it should.
I will make frequent, small, releases so that I do not impede the progress of others.
I will fearlessly and relentlessly improve my creations at every opportunity. I will never degrade them.
I will do all that I can to keep the productivity of myself, and others, as high as possible. I will do nothing that decreases that productivity.
I will continuously ensure that others can cover for me, and that I can cover for them.
I will produce estimates that are honest both in magnitude and precision. I will not make promises without certainty.
I will never stop learning and improving my craft.
https://www.amazon.com/Becoming-Better-Programmer-Handbook-People/dp/1491905530/
From caring comes courage.
To write good code, you have to care about it. To become a better programmer you must invest time and effort.
In any coding situation, you refuse to hack something that only seems to work. You strive to craft elegant code that is clearly correct (and has good tests to show that it is correct).
You write code that reveals intent (that other programmers can easily pick up and understand), that is maintainable (that you, or other programmers, will be able to easily modify in the future), and that is correct (you take all steps possible to determine that you have solved the problem, not just made it look like the program works).
You work well alongside other programmers.
You consider other programmers, and construct code that others can read. You want the team to write the best software possible
Any time you touch a piece of code, you strive to leave it better than you found it (better structured, better tested, and more understandable…).
Keeping Up Appearances
Code
- Communication and maintenance
STRUCTURE WELL
Do not insert blank lines unless there is a natural “paragraph” break. This technique helps to emphasise flow and structure.
The order of code revelation is important. Consider the reader: put the most important information first, not last.
Ensure APIs read in a sensible order. Put what a reader cares about at the top of your class definition. That is, all public information comes before private information.
Don’t write one function with five “paragraphs.”
CONSISTENCY
AVOID REDUNDANCY
class WidgetList
public int numberOfWidgets() { ... }
he context of the enclosing class clearly defines what size means in this case.
Avoid redundant words.
BE CLEAR
Favor clarity over brevity.
BE IDIOMATIC
BE ACCURATE
Write Less Code!
compact/clean code
Cut through the waffle and say things clearly, but succinctly.
Express code clearly and succinctly. Avoid unnecessarily long-winded statements.
Dead code
Functions that are never called
Variables that are written but never read
Parameters passed to an internal method that are never used
Enums, structs, classes, or interfaces that are never used
Verbosity
A lot of code is needlessly chatty.
Clean up after yourself. As you work on a piece of code, remove all of the unnecessary code that you encounter.
Every day, leave your code a little better than it was. Remove redundancy and duplication as you find it.
YAGNI:
even code you think is going to be needed in future versions. Don’t write it now if you don’t need it now. Wait until you do have a genuine need.
It was easier to just implement it now, rather than go back to the customer to see whether it was really required. (Hint: It always takes longer to write and to maintain extra code. And the customer is actually quite approachable. A small extra bit of code snowballs over time to a large piece of work that needs maintenance.)
Looking back over your old code is like a code review for yourself. It’s a valuable exercise; perhaps you should take a quick tour through some of your old work. Do you like the way you used to program? How much have you learnt since then?
Finding old code that no longer feels “right” is a good thing: it shows that you have learnt and improved.
Your best route into code is to be led by someone who already knows the terrain. Don’t be afraid to ask for help!
test - usage pattern
how its going to be used
The best way to learn code is to modify it. Then learn from your mistakes.
DOCUMENT WHAT YOU FIND
If you can, enjoy the chance to tidy. It can be very rewarding to bring structure and sanity to a mess. Rather than see it as a tedious exercise, look at it as a chance to introduce higher quality.
Treat it as a lesson. Learn. How will you avoid repeating these same coding mistakes yourself?
Check your attitude as you make improvements. You might think that you know better than the original author. But do you always know better?
Don’t Ignore That Error
Consider all potential code paths as you write your code. Do not plan to handle “unusual” cases later: you’ll forget and your code will be buggy.
Your primary goal: Add value to others
Chapter 26. Don’t be afraid to look like an idiot
Learning how to learn: How to teach yourself
you have to learn how to swallow your pride and get out there and not be afraid to make a fool of yourself.
TAKE SMALL STEPS (OR DIVE RIGHT IN)
http://www.toastmasters.org/
Don’t copy code you find on the Web into your project without carefully inspecting it first.
Is the code genuinely completely correct? Does it handle all errors properly, or was it only illustrative?
Is it the best way to achieve what you need? Is it an out-of-date example? Does it come from a really old blog post, containing anachronistic code?
Focus on constructing the simplest code that satisfies the requirements right now. Write only what’s needed, and create the smallest, most appropriate API possible.
Promote and Refactor
As soon as you realise that it needs to be used in more than one place, refactor: create a shared library or a shared code file. Move the code in there. Extend the API as little as possible to accommodate the second user.
Accountability
Accountability Counts
Being accountable to other programmers for the quality of your work will dramatically improve the quality of your coding.
Realise that actively putting yourself into the vulnerable position of accountability is not a sign of weakness, but a valuable way to gain feedback and improve your skills.
If you know that someone else will read and comment on your code, you’re more likely to write good code.
Who should be the arbiter of your work quality? Who really knows how well you’ve performed? How can you get them involved? Is it as simple as asking them?
Don’t send someone an email when you need an urgent answer; email can sit ignored for days. Walk over to them, ring them, Skype them. Conversely, don’t phone someone for a non-urgent issue
Master the different forms of communication. Use the appropriate mechanism for each conversation.
Learn. Constantly.
Seek to improve. Constantly. (Yourself, your team, and your code.)
Always deliver value, considering the long term.
How can you quickly recognise when a developer is not performing as diligently as she should?
How can you be sure that you’re not adopting sloppy practices yourself? How can you prevent yourself from slipping into bad practices in the future?
Be diligent, be conscientious, and be professional
learn to collaborate
Purposefully place yourself beside excellent programmers.
Speak Up! Learn to communicate well; listening is essential if you are to learn.
Concentrate effort on the most important things first. What is most urgent, or will produce the most value?
MAKE IT SOMEONE ELSE’S PROBLEM
http://mp.weixin.qq.com/s/2m3cqR-IrEPeXlZpyFn7ig
Code a lot
#2: Be language agnostic. Language is just a tool. It's valuable to know a language deeply, but it's also valuable to be learning new things. The best developers tend not to identify as a ____ developer.
#10: Be helpful. When possible, help people who ask for help. This is a nice thing to do as well as a smart thing to do. These people who ask you for help right now will be much more likely to help you in the future. That "help" might be introducing you to their friends who can help you more directly. So even if you don't see how that person will be helpful, you don't know who their buddies are or will be.
#11: Make friends. You actually can't really be successful by yourself. If you're an entrepreneur, you need employees and business connections. If you're an employee, you need a job. Either way, it's friends who will be key to opening up these opportunities. It's friends, distant and close ones, who form the important part of your network, not that one person you met at a meetup and never talked to again.
#13: Start stuff. Show initiative. Good things come to those who don't wait. Seek out new opportunities. Start stuff - a hackathon, a club, a project, a company, a new running group, whatever. You will learn so much from doing this and it will open doors.
#14: Take risks. Seize opportunities. When you notice that little flicker of opportunity, seize it. Run with it. See where it goes. Don't walk away just because you don't know exactly where it's going to go.
#15: Bias towards "yes." A great career hinges on the "breakthrough" moments. The problem is that you often can't identify those in advance. You don't know where that coffee meeting that you don't see the point in is going to lead. You won't know that, two months down the line, that person will end up introducing you to a guy who needs some advice and winds up as your business partner. Maintain a strong bias towards saying yes.
http://prog21.dadgum.com/87.html
http://www.techug.com/write-code-like-you-just-learned-how-to-program
It's extremely difficult to be simultaneously concerned with the end-user experience of whatever it is that you're building and the architecture of the program that delivers that experience. Maybe impossible. I think the only way to pull it off is to simply not care about the latter. Write comically straightforward code, as if you just learned to program, and go out of your way avoid wearing any kind of software engineering hat--unless what you really want to be is a software engineer, and not the designer of an experience.
http://www.phpxs.com/post/4582
真正的编程能力
编程能力是一种解决问题的能力
如果问题没能被很好地解决，知道再多也没用。
编程能力是一种运用机器解决问题的能力
编程能力是一种抽象问题的能力
借用轮子是很好的办法，省力省时间。今天任何软件工程师都会有意无意地使用很多轮子，从操作系统编译器数据库网络到算法数据结构。想高效地借用轮子，就需要将问题分解再分解，抽象再抽象。任何一个实用的系统（不包括教科书上的示例程序和简单的脚本程序）都需要进行大量的分拆和组合。所以系统设计是编程能力里的高级技能，加合理的假设简化问题尤其有难度，此处不展开讨论。高手和新手的区别在于新手往往不知道轮子的适用范围，而高手的手上轮子数量多且熟知各种轮子的差异，所以对不同的问题可以轻松地找到合适的轮子，当实在找不到合适的轮子时可以自己动手改造现有的轮子。平时有时间拆装和改造已有的轮子会对水平提升有较大帮助。当然能知道怎样快速在搜索引擎里搜出轮子也是一种能力。
编程能力是一种需要考虑扩展性的能力
编程能力是一种取舍的能力
局部的最优解未必是全局的最优解。如果一个美妙的解决方案需要将完工时间向后推迟一两个月，需要考虑是否先使用平凡方案解决问题，之后再进行优化。当你的工作延后会阻碍别人的工作时尤其如此。发现一个绝妙的优化方案时先想想这个优化是否真的有价值，如果只是系统中很小的部分，那么不要为了追求心理满足而花很多时间放一个漂亮的轮子上去（参考Amdahl定律）。
编程能力是一种预见未来的能力
目前的方案有哪些假设和局限性，在何种情形下会遇到问题甚至崩溃。在未来出现问题时问题是否需要重新定义，系统是否需要重新设计，代码是否需要重构或优化等等都需要未雨绸缪。
http://www.csdn.net/article/2014-04-16/2819338-Programmer-Learning
多读经典书
一个善于学习的人，首先要善于利用一切时间来学习。
上班时间看书，不但是一件很敏感的事情，而且非常吸引眼球，很快就会引起周遭的不爽。首先老板心里不爽：“我给你钱是让你来工作的，不是来学习的”；其次同事们也不爽：“我们工作都做不完，瞧，这小子真闲啊”。用不了多久，你就会成为被众人排斥的异类，这最终会让你自己“很受伤”。
要高效学习
只学习与工作相关的东西
最实际的方向，应该跟着工作走，工作需要什么，我们就学什么，把工作需要的技能熟练掌握，有很多好处。
其次，可以学得更快、更深入，因为学习更具有针对性，而且可以立即在工作中运用，可以马上检验出学习的效果。对存在的问题进行深入研究，掌握的知识也会更加牢固。
当我们把学习的焦点放到与工作相关的知识上时，工作时间中的很大一部分，同时也就成了宝贵的学习时间，这真是一举两得的美事啊。
问题是最好的学习机会
“工作就是不断发现问题、分析问题、最终解决问题的过程，晋升之门将永远为那些随时解决问题的人敞开着。
问题其实是最好的学习机会。往往那些愿意接受困难工作的人，能力会越来越强，那就是因为他们在克服困难的过程中取得了巨大的进步。
织网式学习
知识的广度和深度都很重要。作为一名程序员，能深入把握技术细节，是写出优质代码的保证。但对于一名项目经理而言，知识的广度更显重要。项目中碰到的问题往 往具有综合性，只有具备广博的知识，才能快速对问题进行分析和定位。在程序员成长的道路上，我们必须有意识地扩大自己的知识面，形成更完善的知识体系。
经常思考总结
子曰：“学而不思则罔”。人只学习不思考，就会迷惑，难以把握事情的本质。
克服“高原现象”
爱学习的人都会有这样的经历：学习持续了一段时间之后，往往会有一个瓶颈期，长时间似乎都没有什么进步，于是内心非常着急。
高原期，实质是一个消化期。由于前期的学习积累了太多的知识点，这些知识点在大脑中乱作一团，还没有形成一个知识体系。这时需要一定的时间来消化它，让它融会贯通，经常思考总结可以快速帮你跨过高原期。
处于高原期时，还可以换一个相关的方向来学习。例如，编程语言学不下去了，可以学习一下设计模式，设计模式也学不下去了，再换成数据库。通过学习这些相关的知识，不但补齐了知识体系中的短板，而且各个知识点之间可以互相启发，帮助你实现顿悟，跨过高原期。
http://www.raychase.net/3529
http://www.codingdojo.com/blog/trait-of-great-programmers/
Be well rounded.
Enjoy solving puzzles.
Love learning.
Good communication skills. Working as a developer isn’t just about technology. Developers need to talk with business users to understand what they need from the application. Developers also often need to generate technical documents, so being able to write clearly is also important—even if it’s just to produce a status report.
Confidence. There’s never just one way to build a system. No matter how good your ideas are, they won’t have value if you keep them to yourself. The best developers have confidence in their ideas and speak up in design discussions to help shape the application architecture. To boost your confidence, start with a small suggestion, rather than proposing an entire application redesign.
Be interested in the business. Businesses use technology to solve business problems. The more you understand about your company’s business, the better prepared you are to understand their problems and build solutions that help them grow. You should take advantage of opportunities to talk to the business users and ask them questions about the challenges they face in their work. If you get really interested in understanding the business, you can take courses or even work towards certifications in the business domain.
Be a team player.
Understand the importance of deadlines.
once you’ve agreed to do a task, do your best to meet the deadline, even if it means a few late nights. You don’t have to give up your whole personal life for the organization, but demonstrating commitment to completing the project and understanding its value to the business make a positive impression at work.
Be adaptable. Projects and priorities change for many reasons, and developers need to be able to context-switch to focus on what’s most important right now. The changes may be small and temporary or major and permanent. If they’re temporary, make sure you have good notes that will help you get back to your regular work when things settle down. If the changes are permanent, allow time to understand what the new situation is and how you fit into it. It may present new opportunities to help you achieve your goals. In any case, it’s important to respond professionally and not lash out in frustration.
Own your product.
// think how u can improve it, make it better etc.
Technically, your job may be done once you’ve written code that compiles cleanly and passes its test cases. Stand out by following it through the rest of its lifecycle—be willing to help with testing, deployment, training users, and solving production problems. While this helps your business, it actually helps you more, because you see and understand the real-world effectiveness of the code you wrote. Then take that understanding and let it help you make your next application even better.
http://javahungry.blogspot.com/2014/05/how-to-become-good-software-programmer.html
2. Fallacy of Knowing a Number of Programming Languages
3. Studying Books
4. Base of Algorithm
5. Practising Data Structures and Design Related Problems
6. Talking to Experts in the Field
7. Reading Good Blogs and Participating in Coding Communities
http://www.alexparker.me/you-know-nothing-about-code/
3. Don’t Be Afraid to Break Things
4. The Professional Programmer
The single most important trait of a professional programmer is personal responsibility. Professional programmers take responsibility for their career, their estimates, their schedule commitments, their mistakes, and their workmanship. A professional programmer does not pass that responsibility off on others.
If you are a professional, then you are responsible for your own career.
http://pythonpracticeprojects.com/how-benjamin-franklin-learned-to-program.html
Eat a hearty breakfast
Drink water
http://blog.jobbole.com/72699/
1. 解析问题，手工“解决”
2. 想出一个伪代码算法
3. 将算法转换为代码
好学就能显得有智慧（至少能有知识），力行就能不脱离群众（因不忘本而能具备仁慈之心），知耻就能守底线（有所为有所不为之勇）
Read books, do peer reviews, participate in open-source projects
archive all the personal code that they write, no matter the language or subject. Put it somewhere safe (ie. git/svn) and keep it as long as you can. Then once a couple of years have passed, take some time to look at it. There is nothing more gratifying than looking at some old code and thinking: “OMG my code was so stinking awful!!”, nothing more satisfying than executing old handmade programs and games.
You never realize how much improvement you’ve made as a coder until you’ve looked at yourself as a coder a few years back. It lets you become the user of your own creations, and it usually brings back some fond memories.
https://www.quora.com/What-is-the-best-career-advice-for-a-software-developer-to-earn-higher-salary
Invest in skill sets that will pay. No use learning something just because you like it. Learn something for which companies are willing to pay top dollar.
Look at your colleagues who are 10+ years older than you and ask yourself if you wanna be doing the same stuff they are doing today. If the answer is no, find out what you need to do differently so as not to land in the same position as theirs ten years from now.
Make Computer Science fundamentals very strong , mainly DataStructure & Algorithm.
No point of being a master of single technology like Java or Python. Learn several technologies.It will broaden your skill-sets & thinking.
Heard any new technology, like BigData or Machine Learning. Make sure to understand that and implement a POC. Don't just read, make sure, you are very much aware of fundamentals
If you don't like your job or Manager don't react, keep smiling and keep working and look for new job. Never destroy your relationship with people
Blog about what you do. Write white papers on particularly innovative solutions you develop. Write about development best practices, your thoughts on languages and platforms, bug fixes, you name it. If you don't have a blog, you're missing out on the ability to walk into an interview with someone who knows more than just your resume, but also your development style and personality.
Find a problem that a lot of people struggle with that you can solve with your skill set. Write an open source solution, publish it, and maintain it. When you make updates, include the change log in your blog.
如何在大公司中成长
https://medium.com/swlh/busy-but-not-productive-94336103a2a1
Busy, but not productive
Unfortunately, for lots of startups, learning takes the form of doing something and then seeing what happens. That’s not learning. That’s just being busy. True learning requires asking a question and forming a hypothesis before taking action. That action (a test or an experiment) then helps you prove or disprove your hypothesis. In addition, most founders think about learning only in the context of their products. But being productive and focused on learning applies to every aspect of the business. Marketing, hiring, pricing, etc. all need to be hypothesis-driven so that you’re always learning about whether you’re targeting the right customer, hiring someone with the right experience or capturing the right value for your product.
1.如果性能不佳，就在应用层处理，别放在数据库层。
5.不些地方尽量不用注释，因为有时会适得其反。
7.遇到疑问时，和你的小伙伴积极讨论和沟通。
12.努力让自己更积极的面对工作，这样我们才能觉得有趣。
13.有时系统的崩溃仍是自己不原看到的，所以一定要做好日常的监控，记好监控日志，避免出现各种异常，保持系统对故障的敏感度和及时警报。
14.最后一点，要记得做好自己的本质工作，及时处理问题，做好相应对策。
http://www.cnblogs.com/codelove/p/4973334.html
迅哥儿曾经说过，“哪里有天才，我只是把别人喝咖啡的时间用在学习上。”
http://www.jianshu.com/p/7645a5ea7f46
如果一个人有几十年的工作经验，却从来不回头去提炼代码，那么他也许还不如一个只有一两年经验，但是却反复推敲，仔细领悟的人。
尽量减少null指针的出现
模块原则：写简单的，通过干净的接口可以被连接的部件。
清楚原则：清楚要比小聪明好。
合并原则：设计能被其它程序连接的程序。
分离原则：从机制分离从策略，从实现分离出接口。
简单原则：设计要简单；仅当你需要的时候才增加复杂性。
节俭原则：只有当被证实是清晰，其它什么也不做的时候，才写大的程序。
透明原则：为使检查和调试更容易而设计。
健壮原则：健壮性是透明和简单的追随者。
表现原则：把知识整理成资料，于是程序逻辑能变得易理解和精力充沛的。
意外原则：在接口设计中，总是做最小意外的事情。
沉默原则：一个程序令人吃惊什么也不说的时候，他应该就是什么也不说。
补救原则：当你必须失败的时候，尽可能快的吵闹地失败。
经济原则：程序员的时间是宝贵的；优先机器时间节约它。
产生原则：避免手工堆砌；当你可能的时候，编写可以写程序的程序。
优化原则：在雕琢之前先有原型；在你优化它之前，先让他可以运行。
差异原则：怀疑所有声称的“唯一真理”。
扩展原则：为将来做设计，因为它可能比你认为来的要快。
http://qwzs112.iteye.com/blog/2257896
http://blog.me115.com/2014/06/646
https://mp.weixin.qq.com/s/heFyKmlmhYz2dzCgPzRUiw
http://blog.xiaohansong.com/2016/01/16/kownledge-Management/
At first much of it was just the mechanics of the job. Writing code. Communicating. Being a good teammate.
1. Put on a smile
2. Know a domain like it’s your job
Same thing with writing software. Move fast. I’ll make a lot of bad decisions. I’d make a lot of different bad decisions if I sat and thought for days on it.
Find your balance here and you’ll accomplish way more than you did before. Don’t give up your thoughtfulness, but turn thought into action when you reach 80% confidence instead of waiting until you’re 100%.
At work, it’s often best to try a lot of things than to invest yourself wholly into a few. Everything is an experiment. Failures and false starts will happen. By spending less time up front thinking, you’ll find more success and waste less time.
https://mp.weixin.qq.com/s/DwDzOcQZIK9vd6FQTyuIWQ
虽然知识更新很快，但是基础理论的变化却非常缓慢。这就是“道”和“象”关系，纵是世间万象，道却万变不离其宗。对于那些非常基础的理论知识，我们需要经常复习，也就是“学而时习之”。
重视实践
书本知识主要是传道——讲述抽象原型，而对其具体应用场景的讲述往往含糊其辞，对抽象原型之间的关系也是浅尝辄止。采用同样精确的语言去描述应用场景和关联关系将会失去重点，让人摸不着头脑。所以，仅仅通过看书来获得成长就像是用一条腿走路。
重视实践，充分运用感性认知潜能，在项目中磨炼自己，才是正确的学习之道。在实践中，在某些关键动作上刻意练习，也会取得事半功倍的效果。
书本知识主要是传道——讲述抽象原型，而对其具体应用场景的讲述往往含糊其辞，对抽象原型之间的关系也是浅尝辄止。采用同样精确的语言去描述应用场景和关联关系将会失去重点，让人摸不着头脑。所以，仅仅通过看书来获得成长就像是用一条腿走路。
重视实践，充分运用感性认知潜能，在项目中磨炼自己，才是正确的学习之道。在实践中，在某些关键动作上刻意练习，也会取得事半功倍的效果。
重视交流
重视总结和输出
将经验输出，接受别人的检验是高层次的总结。这种输出不仅帮助了别人，对自身更是大有裨益。总结的方式有很多，包括组织分享，撰写技术文章等等。当然“日三省吾身”也是不错的总结方式。总之，多多总结，多多分享，善莫大焉！
解答别人的问题也是个人成长的重要手段。有时候，某个问题自己本来不太懂，但是在给别人讲解的时候却豁然开朗。所以，“诲人不倦”利人惠己。
将经验输出，接受别人的检验是高层次的总结。这种输出不仅帮助了别人，对自身更是大有裨益。总结的方式有很多，包括组织分享，撰写技术文章等等。当然“日三省吾身”也是不错的总结方式。总之，多多总结，多多分享，善莫大焉！
解答别人的问题也是个人成长的重要手段。有时候，某个问题自己本来不太懂，但是在给别人讲解的时候却豁然开朗。所以，“诲人不倦”利人惠己。
重视规划
凡事预则立，不预则废。对于漫长的学习生涯而言，好的计划是成功的一半。
长期规划
- 远离日暮西山的行业。
- 做自己感兴趣的事情。
- 做有积累的事情。
- 一边走一边看，切勿一条道走到黑。
短期规划
- 确定目标优先级。比如：成长、生活、绩效。
- 确定每个目标的下限。从优化理论的角度来看，这被称为约束。比如绩效必须在一般以上，之前已经规划好的旅行不能更改，必须读完《Effective Java》等等。
- 优先为下限目标分配足够的资源。比如，事先规划好的旅行需要10天，这10天就必须预算出去。
- 按照各主目标的顺序依次分配资源。比如，最终分配给学习的时间是10天。
- 在给定的学习预算下，制定学习目标，要激进。然后给出执行方案。比如，学习目标是掌握基本的统计学知识，并成为Java专家。具体方案为：完成《Effective Java》、《Java Performance》、《Design Pattern》、《Head First Statistics》四本书的阅读。
- 对规划中的各学习任务按目标优先级进行排序，并最先启动优先级最高的任务。比如，最高优先级是掌握统计理论，那么就要先看《Head First Statistics》。
对于该方案，要注意以下几点：
- 最低目标必须能够轻松达成的目标，否则，从优化理论的角度来讲，该命题无解。比如，类似“半年内完成晋级两次、绩效全部S、从菜鸟成为Java专家”就不太合适作为最低目标。总之，要区分理想和梦想。
- 主要目标规划必须具备一定的挑战性，需要规划出不可能完成的目标。过度规划本质上是一种贪婪算法，目的是目标价值最大化。因为一切皆有变数，如果其他目标能够提前完成，就不妨利用这些时间去完成更多的学习目标。总之，前途必须光明，道路必须坎坷。
- 各目标之间不一定共享资源，规划不一定互有冲突。
此外，短期规划还可以从如下几个方面进行优化：
- 学习计划最好能结合工作计划，理论联系实际结合，快速学以致用。比如，本季度规划去做一些数据分析工作，那么不妨把学习目标设置为学习统计知识。
- 要灵活对待规划的目标和具体执行步骤，需要避免“郑人买履”式的笑话。面临新的挑战和变化，规划需要不断地调整。
https://henrikwarne.com/2015/04/16/lessons-learned-in-software-development/yo
https://henrikwarne.com/2014/12/15/programmer-knowledge/
KNOWLEDGE IN 3 DIMENSIONS
Programming. This is programming languages, paradigms, techniques and tools. Like I wrote above, there are many core concepts that are the same, even if the details (like syntax) varies.
Domain. This what you know about the environment in which the program is used. For example, if you work in telecommunications, it is the knowledge of how the various protocols work, how an SMS is processed, how billing and monitoring is done etc. The longer you work in a certain sector, the more you learn about it, and the more valuable your contributions can be.
Codebase. This is specific to a company. When you have worked for a long time, you know your way around the code. You know where things are done, which parts are tricky and unintuitive, and the history of why something is done a certain way.
https://henrikwarne.com/2012/06/02/why-i-love-coding/The sheer joy of making things
The pleasure of making things that are useful to other people
The joy of always learning, which springs from the nonrepeating nature of the task
https://henrikwarne.com/2014/06/30/what-makes-a-good-programmer/
1. PROBLEM DECOMPOSITION
Programming is about solving problems. But before you write any code, you need to be clear on how to solve the problem. One skill good programmers have is the ability to break the problem down in smaller and smaller parts, until each part can be easily solved. But it is not enough simply to find a way to solve the problem. A good programmer finds a way to model the problem in such a way that the resulting program is easy to reason about, easy to implement and easy to test.
Some of the most complicated programs I have worked on were complicated in part because the implementation did not fit the problem very well. This led to code that was hard to understand.
2. SCENARIO ANALYSIS
Good developers have the ability to consider many different scenarios for the program. This applies both to the logic in the program, and to the internal and external events that can occur. To consider the different paths in the logic, they ask questions like: What happens if this argument is null? What if none of these conditions are true? Is this method thread-safe? To discover what types of events the software needs to handle, they will ask questions like: What if this queue becomes full? What if there is no response to this request? What if the other server restarts while this server is restarting?
The good programmers ask themselves: How can this break? In other words, they have the ability to think like testers. In contrast, inexperienced programmers mostly only consider the “happy path” – the normal flow of control when everything goes as expected (which it does most of the time). But of course, the unexpected inevitably happens, and the program needs to be able to cope with that.
3. NAMING
Programming consists to a large degree of naming things: classes, methods and variables. When done well, the program becomes largely self-documenting, meaning that the function of the program is quite clear just from reading the source code. One effect of self-documenting code is that it naturally leads to many smaller methods, rather than a few large ones, simply because then you have more places to put meaningful names (there are other reasons why many small methods are good too).
Naming things well also includes coming up with concepts to be used, and what these concepts should be called. By having well-thought out, distinctly named concepts that are used consistently (in the program, and when discussing the domain with programmers and non-programmers), writing the program becomes much easier.
4. CONSISTENCY
Perhaps the biggest challenge in programming is managing complexity. Consistency is one way to combat complexity. It reduces some of the complexity by allowing us to see patterns and infer how things are named, used and handled. With consistency, we don’t need to use brain power to remember exceptions and random variations. Instead we can concentrate on essential complexity, not accidental complexity.
Consistency is important across the board. It applies to variable names and grouping, method naming, the division into modules, the directory structure, the GUI, error handling, logging, documentation etc. For example, if some variables are related and appear together (in declarations, method calls or as columns in the database) then always use them in the same order. Then it becomes easier to see if one is missing, or if they have been mixed up. For an operation, if it is called delete in one place, don’t call it remove in another place – stick with the same name. Steve McConnell also has some good advice on using opposites precisely in Code Complete. For example, begin/end are opposites, as are start/stop. Don’t mix names from different pairs (for example using begin/stop) when dealing with opposites.
Inconsistencies can get introduced when modifying a program. Sloppy programmers don’t pay attention to if what they add is consistent with the existing code or not. Good programmers are relentless in ensuring that seemingly small details are just right. They know how important consistency is in the overall fight against complexity.
https://henrikwarne.com/2016/04/28/learning-from-your-bugs/
Every time I fix a particularly tricky or interesting bug, I take a few minutes to write down some facts about i
Symptom/Root Cause/How Found/How to Fix/Lessons
It is only when the bug, or the fix, or the debugging of it was particularly interesting that I add a new entry. Usually, I caused the bug. But occasionally, especially when hunting down a difficult bug over many days, I will add an entry even if I didn’t cause it.
Once a bug is fixed, my first reflex is to breathe a sigh of relief and move on. However, I try to write the entry immediately after it has been fixed. That’s when all the details are still fresh in my mind. Waiting makes it much harder to remember exactly what happened (or I forget to write an entry at all).
The most important section is Lessons. This requires some introspection. What made this bug special? I have found that the lessons usually come in three different areas:
Coding. What mistakes did I make in the code? Did I forget an else-part? Was there a system call that failed, but the response wasn’t checked? How can I adjust my coding to avoid these problems in the future?
Testing. Sometimes it is clear from the bug that it should have been caught in testing. If so, testing at which point – unit, functional, system? What test case was missing?
Debugging. How could I have sped up finding this bug? Did I have the right tools? Did I assume too much? Do I need better logging in the code?
Errors are rich in information
By writing down an entry in the bugs file for each interesting bug, I find that I learn much more easily. There is something with the act of writing that makes me think more deeply about what happened. Also, once it is written down, I can go back afterwards an check what happened. Once in a while I will also browse through the file, reading only the lessons section, to reinforce what I thought was the most valuable lesson from each bug.
High-leverage activities. A key concept in the book – focus your effort where the impact produced, divided by time invested, is the highest. There are numerous examples of this throughout the book. For example, creating a strong onboarding program for new engineers amplifies your efforts, since all new hires become productive faster, year after year.
Optimize for learning. Examples: master your programming language, work on a diversity of projects, jump into code you don’t know, read books, attend meetups and conferences, write to teach. If you improve just 1% every day, you will become 37 times better in a year.
Invest in time-saving tools. Learning editor/IDE shortcuts, configuring automatic reload on changes, writing scripts for repetitive tasks etc are small improvements that together can add up to large gains. Furthermore, when activities are faster and easier, they get done more often, and can sometimes enable new workflows that weren’t previously possible, such as continuous deployment.
Continuous deployment
Shorten the debugging loop. When debugging or testing code, we should use our abilities as developers to shortcut normal system behavior. For example, instead of clicking through a workflow, we could use an URL parameter, set a cookie, or modify some code in order to go straight to the buggy state. Having a tight feedback loop when debugging or testing changes makes a big difference.
Don’t sprint in the middle of a marathon. When you are behind schedule and a deadline looms, it is tempting to start working more hours. But the author lists several reasons why this may not help, for example: hourly productivity decreases with additional hours, you are probably more behind schedule than you think, you incentivize technical debt, you risk burning out etc.
Recovery over prevention. Preventing bugs eventually produces diminishing returns. At that point, it makes more sense to invest time and energy in making sure you can recover quickly from failures, instead of doing more to prevent failures in the first place.
Automate mechanics, not decision making. In operations, relentlessly automate mechanical tasks, such as building and deploying software, restarting a service, capturing and restoring a database snapshot etc. However, tasks that require making a decision, such as when to failover to another server, are often better left to a human. This is because it can be hard to get this logic right, since it is hard to test and happens rarely, and it can often make matters worse (e.g. rebalancing to remaining servers overloads those servers).
Make batch processes idempotent. If a batch script fails, it should be possible to re-run it without causing problems. This is possible if it is without side-effects, such as holding onto a global lock, double-counting values or corrupting an output file. If it is idempotent, you can safely re-run it if it failed, which helps enormously when trying to find out why it crashed in the first place. Also, it should be possible to manually run periodic scripts (for example monthly jobs) more frequently for testing purposes, without causing problems.
https://henrikwarne.com/2017/05/28/developers-talk-to-people/Developers – Talk To People
So by just discussing for a few minutes, we found a better solution. I think of this as an informal design review, similar to a code review, but done before implementation, not after. I frequently try to discuss a change with a colleague before going ahead and doing it. Time and again I am grateful that I did. Many times we discover flaws, or better solutions, that I would never have thought of, no matter how hard I tried. So with a little bit of discussing, I end up with much better solutions.
In a lot of cases, talking to developers, testers, product managers and other stake-holders is beneficial to both parties. It is usually also faster than written communication. Despite this, I see many developers that are a bit reluctant. If you are one of those developers, make an effort to talk more to people for a few weeks, and see if it makes a difference.
https://stephenhaunts.files.wordpress.com/2014/04/10-ways-to-be-a-better-developer.png
Learn a scripting language. Being able to write small scripts to automate tasks on the command line or to filter out information from a log file containing 100,000 lines is quite useful. Make sure to learn how to use regular expressions, and a language like Ruby, Python or Perl. All those languages are also used for “serious” applications, but even just using them for quick shell scripts is worthwhile.
Learn an IDE and a text editor well
Hacker News and Proggit. There are always interesting articles related to programming at both Hacker News and reddit/r/programming. Just remember to not spend too much time there – program instead. But for inspiration these sites are great.
To remember. When I read a book on programming or take a MOOC course, I usually write a review of it. Knowing that I will write a review makes me learn the material much better – I am learning more actively. I take notes and try to summarize the most important takeaways. I also think more about what I liked the most and the least, as well as how it compares to what I already know about the subject. Hopefully the reviews are also valuable for people considering reading the book or taking the course.
http://blog.longjiazuo.com/archives/4359
“在我离开Nikola实验室前，我带着始终没有完全解开的谜，问他：如果你不怎么读论文，又不怎么去听讲座，你怎么还能做一个如此出色的科学家？
他回答说：（大意）我的时间有限，每天只有10小时左右在实验室，权衡利弊之后，我只能把我的有限时间用在我认为最重要的事情上，如解析结构、分析结构、与学生讨论课题、写文章。如果没有足够的时间，我只能少读文章、少听讲座了。 ”
施一公进而想到：
“在博士生阶段，尤其是前两年，我认为必须花足够的时间去听各相关领域的学术讲座、并进行科研文献的广泛阅读，打好critical thinking的基础；但随着科研课题的深入，对于文献阅读和学术讲座就需要有一定的针对性，也要开始权衡时间的分配了。 ”
施一公的故事里，除了是时间管理的问题外，更核心的是当一个人在某个领域积累的知识和经验足够的时候，当你真正下过大工夫以后，在你的这个领域内前人有那些积累、有那些高手在研究什么专注什么优缺点是什么，这个时候你是已经了然于胸的。
在这个时候，许多人没必要去见，许多书其实也没必要读！在现在的环境下，如果你想了解一个人干过什么、正在干什么，不一定要去见人而只需要看他分享的东西也就差不多了。而任何一个领域的知识有所进步，都是一个艰难的过程，每次的进步一定是很小很小的积累起来的，所以大部分书其实不过是颠来倒去讲那些成熟的道理而已。
这也是为什么许多人说一天可以读一本书，甚至几本书的原因，如果这个领域的东西他都掌握了并实践过，大部分书他可能只需要找一下自己不熟悉、或者有新说法的地方看两眼就够了！
在我学习知识管理的过程中，曾经有过一个遍历的阶段：在那个阶段将大部分的书都买了，搜索引擎的网页前一百页、论文库里这个领域的大部分论文（国内和国外的）、各种各样的案例等。在这个过程的初始阶段，总会看到一些自己不理解的东西，知道这是自己所欠缺的，然后想办法补上。
当然这个过程是要有几个反复，一段时间觉得自己懂了，但可能后来又发现还是有许多盲点，那就继续去查漏补缺！
大部分人穷其一生都是在借鉴别人的内容，而顶尖高手则除了借鉴外，还能为人类你这个领域生产出一些知识。当你对所在领域的内容都真正掌握的时候，你其实是可以感觉得到，因为在你的前面已经没有人了。这个时候你需要去创造知识。
1. 自我驱动能力强主动找活，主动贡献。从来不给自己设限和边界，认为所有的技术难题，自己都需要去了解和解决，越是自己不熟悉的领域，反而越有动力去学习。工作中遇到技术问题，愿意主动站出来找方案或者带着团队去解决。
2. 责任心/闭环意识一个活交付出去，不是活的结束，而是开始。技术牛人们会不断收集上下游反馈，持续改进。例如，一个新功能上线，会持续观察线上的数据情况，分析功能的使用过程，从终端用户搜集反馈意见。
3. 对舒适区的厌恶
珍惜自己的时间，不断的去寻求技术挑战，技术上一直停留在一个地方，就是浪费生命。成功是偶然的，也是必然的。一个技术人，不停的向前探索，他成功的概率一定比“停留”在一个地方的人会更高。要不断提升自己的技术内功，还是仅仅应付工作，决定了技术上能走多远。
4. 大局观
要想做到技术强人，必须要有整体的业务意识。盯着自己一亩二分田的人，很难担当重任。比如开发一个功能，除了把功能相关需求和设计搞清楚，是不是可以了解一下功能的业务场景是什么，解决客户什么问题，这个功能发布在什么版本，该功能的关键程度是多少？
5. 自律的能力最后的最后，需要的是自律的能力。因为它几乎是每个人实现任何目标或者梦想的前提
精力固然和每个人的体质相关，但保持旺盛的精力的前提是拥有极强的自律能力。从我身边的这些牛人们看，都是十年乃至十五年如一日的自律生活，让他们即便在35岁以后还能够保持良好的身体和精神情况。而旺盛的精力，也是他们成功的关键和基础。
https://mp.weixin.qq.com/s/t1P0mw9Hf4y27EiZB2biXwDo more
做的更多，做的比你主管安排给你的任务更多。
我在HW的时候，负责一个版本的开发，这个版本的工作量大约是2000行左右，但是我除了做完这个功能，还将关联的功能全部掌握清楚了，代码（大约10000行）也全部看了一遍，做完这个版本后，我对这个版本相关的整套业务全部很熟悉了。经过一两次会议后，大家发现我对这块掌握最熟了，接下来就有趣了：产品讨论需求找我、测试有问题也找我、老大对外支撑也找我；后来，不是我负责的功能他们也找我，即使我当时不知道，我也会看代码或者找文档帮他们回答。最后我就成了我这个系统的“专家”了。虽然这个时候我还是做业务的，还是写业务代码，但是我已经对整个业务都很熟悉了。
以上只是一个简单的例子，其实就是想说：要想有机会，首先你得从人群中冒出来，要想冒出来，你就必须做到与众不同，要做到与众不同，你就要做得更多！
怎么做得更多呢？可以从以下几个方面着手：
1）熟悉更多业务，不管是不是你负责的；熟悉更多代码，不管是不是你写的
这样做有很多好处，举几个简单的例子：
- 需求分析的时候更加准确，能够在需求阶段就识别风险、影响、难点
- 问题处理的时候更加快速，因为相关的业务和代码都熟悉，能够快速的判断问题可能的原因并进行排查处理
- 方案设计的时候考虑更加周全，由于有对全局业务的理解，能够设计出更好的方案
2）熟悉端到端
比如说你负责web后台开发，但实际上用户发起一个http请求，要经过很多中间步骤才到你的服务器（例如浏览器缓存、DNS、nginx等），服务器一般又会经过很多处理才到你写的那部分代码（路由、权限等）这整个流程中的很多系统或者步骤，绝大部分人是不可能去参与写代码的，但掌握了这些知识对你的综合水平有很大作用，例如方案设计、线上故障处理这些更加有含金量的技术工作都需要综合技术水平。
“系统性”、“全局性”、“综合性”这些字眼看起来比较虚，但其实都是技术大牛的必备的素质，要达到这样的境界，必须去熟悉更多系统、业务、代码。
3）自学
而有的同学，写了几年的java代码，对于stop-the-world是什么概念都不知道，更不用说去优化了。
Do better
要知道这个世界上没有完美的东西，你负责的系统和业务，总有不合理和可以改进的地方，这些“不合理”和“可改进”的地方，都是更高级别的怪物，打完后能够增加更多的经验值。识别出这些地方，并且给出解决方案，然后向主管提出，一次不行两次，多提几次，只要有一次落地了，这就是你的机会。
例如：
重复代码太多，是否可以引入设计模式？
系统性能一般，可否进行优化？
目前是单机，如果做成双机是否更好？
版本开发质量不高，是否引入高效的单元测试和集成测试方案？
目前的系统太庞大，是否可以通过重构和解耦改为3个系统？
阿里中间件有一些系统感觉我们也可以用，是否可以引入 ？
只要你去想，其实总能发现可以改进的地方的；如果你觉得系统哪里都没有改进的地方，那就说明你的水平还不够，可以多学习相关技术，多看看业界其它优秀公司怎么做。
我2013年调配到九游，刚开始接手了一个简单的后台系统，每天就是配合前台做数据增删改查，看起来完全没意思，是吧？如果只做这些确实没意思，但我们接手后做了很多事情：
- 解耦，将一个后台拆分为2个后台，提升可扩展性和稳定性；
- 双机，将单机改为双机系统，提高可靠性；
- 优化，将原来一个耗时5小时的接口优化为耗时5分钟
还有其它很多优化，后来我们这个组承担了更多的系统，后来这个小组5个人，负责了6个系统。
Do exercise
在做职业等级沟通的时候，发现有很多同学确实也在尝试Do more、Do better，但在执行的过程中，几乎每个人都遇到同一个问题：光看不用效果很差，怎么办？
例如：
- 学习了jvm的垃圾回收，但是线上比较少出现FGC导致的卡顿问题，就算出现了，恢复业务也是第一位的，不太可能线上出现问题然后让每个同学都去练一下手，那怎么去实践这些jvm的知识和技能呢？
- Netty我也看了，也了解了Reactor的原理，但是我不可能参与Netty开发，怎么去让自己真正掌握Reactor异步模式呢？
- 看了《高性能MySQL》，但是线上的数据库都是DBA管理的，测试环境的数据库感觉又是随便配置的，我怎么去验证这些技术呢？
- 框架封装了DAL层，数据库的访问我们都不需要操心，我们怎么去了解分库分表实现？
诸如此类问题还有很多，我这里分享一下个人的经验，其实就是3个词：learning、trying、teaching！
1）Learning
这个是第一阶段，看书、google、看视频、看别人的博客都可以，但要注意一点是“系统化”，特别是一些基础性的东西，例如JVM原理、Java编程、网络编程，HTTP协议等等，这些基础技术不能只通过google或者博客学习，我的做法一般是先完整的看完一本书全面的了解，然后再通过google、视频、博客去有针对性的查找一些有疑问的地方，或者一些技巧。
2）Trying
2）Trying
这个步骤就是解答前面提到的很多同学的疑惑的关键点，形象来说就是“自己动手丰衣足食”，也就是自己去尝试搭建一些模拟环境，自己写一些测试程序。例如：
- Jvm垃圾回收：可以自己写一个简单的测试程序，分配内存不释放，然后调整各种jvm启动参数，再运行的过程中使用jstack、jstat等命令查看jvm的堆内存分布和垃圾回收情况。这样的程序写起来很简单，简单一点的就几行，复杂一点的也就几十行。
- Reactor原理：自己真正去尝试写一个Reactor模式的Demo，不要以为这个很难，最简单的Reactor模式代码量（包括注释）不超过200行（可以参考Doug Lee的PPT）。自己写完后，再去看看netty怎么做，一对比理解就更加深刻了。
- MySQL：既然有线上的配置可以参考，那可以直接让DBA将线上配置发给我们（注意去掉敏感信息），直接学习；然后自己搭建一个MySQL环境，用线上的配置启动；要知道很多同学用了很多年MySQL，但是连个简单的MySQL环境都搭不起来。
- 框架封装了DAL层：可以自己用JDBC尝试去写一个分库分表的简单实现，然后与框架的实现进行对比，看看差异在哪里。
- 用浏览器的工具查看HTTP缓存实现，看看不同种类的网站，不同类型的资源，具体是如何控制缓存的；也可以自己用Python写一个简单的HTTP服务器，模拟返回各种HTTP Headers来观察浏览器的反应。
还有很多方法，这里就不一一列举，简单来说，就是要将学到的东西真正试试，才能理解更加深刻，印第安人有一句谚语：I hear and I forget. I see and I remember. I do and I understand ，而且“试试”其实可以比较简单，很多时候我们都可以自己动手做。
当然，如果能够在实际工作中使用，效果会更好，毕竟实际的线上环境和业务复杂度不是我们写个模拟程序就能够模拟的，但这样的机会可遇不可求，大部分情况我们还真的只能靠自己模拟，然后等到真正业务要用的时候，能够信手拈来。
3）Teaching
3）Teaching
这样的例子很多，包括我自己写博客的时候经常遇到，本来我觉得自己已经掌握很全面了，但一写就发现很多点没考虑到；组内培训的时候也经常看到，有的同学写了PPT，但是讲的时候，大家一问，或者一讨论，就会发现很多点还没有讲清楚，或者有的点其实是理解错了。写PPT、讲PPT、讨论PPT，这个流程全部走一遍，基本上对一个知识点掌握就比较全面了。
https://mp.weixin.qq.com/s/--sD1nrO6A4xcXlRuwgnnA
喜欢收藏，而不是直接消化吸收。 这个更是个普适性问题，你现在就可以找找你的电脑硬盘里、微信收藏里、云盘里都藏了些啥？都看过吗？大部分的回答应该是先收藏等有时间再看，这跟松鼠无节制的收集松果是一样的。怎么破？先看了再说，如果没时间看的话，排个队列后期再看，如果感觉没时间看的话，索性也不要收藏了。
不参与团队活动。 一个团队中部会发现一些比较安静的同事，特别是喜欢坐在一些角落里的同事，平时不出来活动，很容易忽略他的存在，更别提集体活动。这样非常不利于职场发展，金子发光也要让别人看到，更何况常有的情况是没有发光。同事间也需要维系一种职场情感，来形成职场工作的润滑剂，同时也是给自己积累人脉，日后难免有交集，在这个信息爆炸的时代，个体需要依赖于团队才能走的更远，如果自己仅作为一个团队的附庸，很难有所作为。
不能自我激励。 当激情褪却，兴趣不再，如何再去敦促自己去完成一件原先兴冲冲的事呢？往往这个时候，事情就会搁置，不了了之，而成熟的人总会找到自我激励的方法。生活是自己的，没有谁应该在旁催着你促着你，如何不能自打鸡血，随着时间推移，说一事无成也不为过。
忌惮与女生打交道
https://mp.weixin.qq.com/s/hMS-I1ubRjZTHvT7jTOGLA
不依规范行事。 这个很常见，嘴上一套，行动时另一套，也就是知行不一。实际是知易行难，不自我监督，不自我约束，整个人都会变的懒散。“这个版本着急上线，先把功能实现再说，后面有时间再来重构优化”，是不是经常听到这样的套路，他们事后有重构吗？你自己事后有去看看哪些糟糕的代码吗？如果事出紧急事后完善也是允许的，就怕是个幌子，事后弃之九霄云外。
想做却不迟迟不行动。 非得万事俱备了才行动，其实很多时永远没有完备的时候，先动起来再说，再行动的过程中肯定会遇到问题，去解决就是了。否则有的只是眼前的苟且，不会有诗和远方。“成功学”里讲，想成功与要成功是两回事，虽然是一字之差。
不能虚心学习别人的长处。 都说文人相轻，其实IT界也有一条鄙视链，我们也总在有意无意见践行着这条鄙视链。即便是同一条链上的蚂蚱也存在相互不顺眼的时刻。但学习这东西，要虚心，不能说你看不惯他，就拒绝他身上一切事物，那怕是好的，这真的是跟自己过不去。你有看不惯的人吗？你发现他身上有你不具备的东西吗？
会很多开发语言但不都精通。 不排除大牛做的到，一般人的话，你这么写简历，还真不会让人高看一眼，很容易给别人留下一个什么都会，基本上又什么都不会的印象。不要追逐新技术，技术迭代的速度远比你学习的速度快的多，求多往往会不深入，止于皮毛，而一个技术的应用绝不是写个“hello world”就算的，应用到实际业务场景，解决实际的需求痛点才能发挥一项技术的本真。
软件研发技能单一。 软件生命周期里除了编码实现，还有需求分析、系统设计、测试部署、发布上线、运维运营等等，只盯着代码那一块太狭隘，特别是工作时间长了之后，局限性会越来越明显。开发语言是工具，不用锤子用榔头一样敲东西。要提高自己的适应性，就得外延技能线，后面的职业路也会更宽广，而不是局限在技术一条线。追求全栈没有错，但要适度，不能盲目的为了简历上几行字，去涉猎那些看似有用，但实际并不会实际的技术。
缺乏危机意识。 去年的热点话题事件就是中兴的一位40多岁的IT人自杀。雪球上针对这一问题爆发了“中年危机”的大讨论。中年危机是八零后绕不开的一个问题，张爱玲在《半生缘》里说，“中年以后的男人，时常会觉得孤独，因为他一睁开眼睛，周围都是要依靠他的人，却没有他可以依靠的人。”手机屏幕前的你考虑过这个问题吗？
那些会阻碍程序员成长的细节[4]
不愿意跟领导走的近。 是不是有这样的体会：凡事有领导在的场合，气氛都比较凝重？整个人都放不开？其实这还是一个雇佣关系在作怪。员工与领导并不是处于一个合作互利互惠状态，也就是《联盟》一书中讲到的合作关系。如果还没看过的话，建议你去买来读一读。跟领导走的近有什么坏处吗？不能偷懒了是真的。在我看来，跟高管成为朋友是对职业生涯有益的事情。可以让领导更深入的了解你，可以站在比自己更高的维度去待人接物，可以接触到很多更高层次的人脉等等等等等，还有很多，待你去发掘。如果有机会，千万不要躲的远远的。
缺乏理财意识
频繁的变换行业。 信息化的触角已深入到各行各业，但行业与行业间的业务差别很大，而且有些行业的壁垒高、专业性很强，比如医药、财务等。技术服务于业务，如果你的适应性很强，融会贯通的能力很强倒也无妨，但大部分情况下是刚接触一个还没深入就结束了，如果不能保持连贯，很可能到此就结束了。实际业务运行过程中的核心点需要一定的积累才能掌握，这就需要在行业里沉淀多年才能达到，比如专注金融行业，但里面也会涉及保险、证券、银行等几种业务场景，每一种又是繁杂多变，如果频繁变换从事的行业，基本上谈不上沉淀，随着工作年限的增长，自己的竞争力却没有提到提升，错失成为业务专家的能力。
与他人沟通不畅时，不能本着解决问题的思想来解决问题。 “好，好，好，不说了，打住，我不跟你争了，就按你说的来，有问题你负责”。如果是本着解决问题的目标去解决问题，我们可以摆事实，讲论据，把各种方案存在的利弊得失放在明面上，然后大家再客观的就事论事，拿出一致的解决方案。你会时常碰到一些人在讨论问题时，最后的结果是一方不愿意再争论而妥协，但并非心服口服的妥协，这是直接撂挑子，而不是解决问题。
跟踪问题不彻底，导致前功尽弃。如果别人欠一大笔钱，想必你无论如何都会想尽一切办法，把这笔钱追要回来。很可惜的是，在日常的工作中，我们跟踪一个任务的时候却远不如追账那么用心，跟着跟着然后就没然后了。可想而知，如果都这种状态的话，你的项目进度，你的销售目标，你的市场份额如何达成，试想有一天你成高层领导，你手下的兄弟都是这个状态跟踪问题，那你真的是得操碎了心也搞不定。
不停追逐新技术，由于不能应用于实际工作，导致很快被遗忘。 技术更新迭代的速度远非一个人穷一生之力所能学完的，所谓以有限的生命去掌握无限的技能仅仅是美好的事，但不现实。考虑到具体的技术成熟度、应用场景与自己的工作实践的匹配度，只能是那些切实应用于实践的技术栈才能更快更深的掌握住。具体到自己的职业规划中，更应当聚焦，找准一个点，基于这个点再外延，打造自己的技术生态圈。切忌把自己打造成一个掌握很多技术但无关度很高的瑞士军刀，其竞争力远不如一技之长。
- 减少任务切换的代价
- 提升思考问题的能力
- 锻炼写作能力
- 管理任务与时间
https://mp.weixin.qq.com/s/6zVBuQQTepLSXjkLA5qEqA
什么叫任务驱动？就是我干这件事是有我要解决的问题的，我是奔着我的目标去的。现在很多 App 很多产品都提倡利用你的碎片化时间，所以你就扑腾扑腾不断跑来跑去捡了很多的树枝，后来发现自己的院子里堆满了树枝，而想象中的参天大树毫无踪迹。碎片化时间的基础是，你要有自己强壮的主干，慢慢去吸收阳光吸收养料，碎片化地成长树叶和树枝，这样子你才有成为参天大树的可能，否则就只是在院子里堆满树枝了。
不经意间，这些小细节慢慢写成了一个系列。俗语讲：魔鬼在细节中，小处做到极致，养成的好习惯，也是让自己未来的技术晋升之路更加坚实。
不能主动推动事物前进。 主动做一件事跟被动接受去做事，心情都是不一样的，做事效率更是千差万别。主动的人有更多的成长机会，反之在被动中不断的响应别人的任务，这与处于那个层次高低无关。如果处于高层级却不能主动推进任务前进，相信在这个岗位上也不会呆太久。
技术交流分享会仅仅是听听而已。在一线城市这种机会特别多，如果你愿意，一天可以赶好几场。虽说是别人分享，如果没有好好利用，仅仅参加完就离开的话，效果几乎为零。可以事先熟悉讲师履历、分享的内容，带着自己的疑问听，不懂处记录在册，答疑环节将疑问点抛出，多认识些分享会上的人，加入分享会微信群会后继续讨论等等，都能更好的发挥一次分享会的效能。不要让参加技术分享会流于形式。
无法多场景切换角色。 刚入门时，醉心于开发还是有可能的，随着年限的增加，个人职责会发生改变，再有整块整块的时间去专心某一事务的机会不多，更多的是碎片化的时间切片，面对不同同事、客户、领导、合作伙伴等等，如果不能快速响应各种变化，只能用疲于奔命应付来形容了，工作的条理性更无从谈起。你需要快速切换角色，融入不同环境，能抽象，也能具化，能全局把握，也能细节深入，这样处理起问题才能得心应手，迅速成长。
容易陷入细节。 或者说很纠结细节问题，相对的另一面会导致全局观缺失，偶尔还会钻牛角尖。过于追求细节完美的人，也就是完美主义者，事实时完美在现实生活中不可能存在。陷入细节而不自知轻则项目延期，重则错过市场窗口期。把握一个度很重要，需要以大局为重时，就需要牺牲局部的不完善。
不插手开发任务外的其他事务。临时任务在所难免，特别是创业团队，更是没有明确界线的岗位分工，需要时，直接顶上，目标就是把事情做成。仅关注开发任务那点事，显然不足以为更高的岗位做技能储备，如果力所能及又不占用过多时间的话，建议去锻炼一下。经历都算自己的，成长过，谁也拿不走。
不注重关键节点的记录留存。 人员流动、业务变更对软件后续的维护都是挑战，仅靠脑袋记，显然不现实。很多朋友说，代码里都有啊，看代码就行了。如果必须拿代码才能说事的话，只能说你太不成熟，设计文档、流程图、数据表格这些辅助理解的东西简直难道是摆设？特别是一些复杂的业务流程设计、复杂算法设计、疑难BUG解决方案等等。虽然敏捷开发不主张凡事以文档必备为准，但必要的文档留存很重要，形式可以不限。
领导安排什么就做什么，做完了就闲着，也不学习新业务新技能。闲下来就刷刷微博朋友圈，看看新闻聊聊天，这是典型的打工者思维，上班工作，某种意义上也是自己创业的过程，在公司的体系下，利用对应的资源来达成自己的目标，本质上与自己出来创业完成某个目标，路径是差不多的。在别人现有的环境里，不能以自己创业心态来待人接物，简单就是一个浪费，这是一个很好锻炼的机会，主动去承担更大的责任，更多的任务。诚然，做的多，出错的概率会更大，但试错的成本很低，成长的机会也更多，没有什么能比成长更好的啦！
任务有交叉时，只关注自己的，不能从上下游全局统筹。这其实是个合作意识的问题，需要双方或多方都比较爽才行，而不是只让自己爽，让别人很别扭。久而久之，自己会被孤立，这不是单次博弈，而是重复博弈，最优策略就是共赢。
自己做的比较快，但旁边的兄弟任务似乎比较重，而自己又不施与援手。个体技能的不同必然导致结果差异，但对于团队而言，需要的不仅仅是个体的成绩，而是团队的协作产生的高效率、高质量。这也是一个重复博弈的过程，难保自己有遇到困难的时候，你难道不希望有人搭把手共同解决问题？人同此心，心同此理，相互扶持，这是团队作战的魅力。
不及时反馈工作进展。做事最忌讳的就是虎头蛇尾，多数情况下会无疾而终，不了了之。对于被指派的任务最好的做法是及时上报风险、暴露困难，及时汇报进度，这样即便是达不到工作目标，整个过程也是有目共睹的。领导最怕的做法就是任务下发后，下面的也保证完成任务，但真到交活了，摆出一堆这样那样的理由，任务就是没有完成。当你没有把握给领导惊喜的时候，及时汇报工作进度，免得到最后只有惊吓，为时晚矣。
伸手党。到论坛里、社群里随便一看就能抓出来一堆，目的就是为了更快达成目标，但又能力不足或偷懒，而完全依赖于他人，最好是他把需求一提，你把交付物一给就算完事。还有一种情况，出现问题后，不经深入分析，直接找别人来解决。长期伸手而不真正上手操练，业务能力自然下降，只能自尝苦果。有句话讲：你可以像只猪一样懒，却无法像只猪一样，懒得心安理得。这才是痛点。
课余时间不充电。下班后基本处于散养状态，工作基本吃老本，或者勉强能对付，工作上基本没什么大起色，不算差但也不算好。之前讲“你只有不停的奔跑，才能停留在原地！”，凸显出时代的变化之块，不是大鱼小鱼，而是快鱼吃慢鱼，特别在一些生活、工作节奏都比较慢的二三线城市。人与人之间的差距并不是在工作八小时内拉开的，起决定作用的而是工作之外，所谓工夫在诗外。技术更新迭代的速度远超任何一个时代，比我们优秀的人还在拼命，我们又有什么理由懒惰呢？
1，懂业务
不是吧，一个好码农的第一个特质居然是“懂业务”。“懂业务”的真实含义是“非常清楚自己开发出来的程序的功能目标”，只有目标清晰，才能更好的达成目标。例如：一种初级码农的表现是交付代码后，发现部分功能不是业务期望的，需要返工重写；一个中级码农的表现是交付代码后，功能基本都满足了业务的期望；一个优秀码农的表现是交付代码后…...，不不不，一个优秀码农的表现是在收到需求时，基于自己对业务的理解，和产品、业务同学讨论后，给出了更好的解决方案，在交付代码后，观察和跟进业务效果。
2，读代码，用代码说话
进入一个团队和项目的时候，需要全新开发的机会很少，一般都要阅读别人的代码。不管前人代码如何如何，一个优秀码农都会通读相关并理解其中的思路，只有理解了代码以及其中的业务逻辑，才能更好的增加代码和业务，才有发言权，“读代码”是一个优秀码农的特质；和“读代码”对应的是“用代码说话”，“Talk is cheap, show me the code.”是大神的名言，也是优秀码农必备的特质。夸夸其谈的架构师永远无法使业务需求run起来。
3，对技术有热情并深入
4，高质量
5，高效率
普通的搬砖工人A和优秀的搬砖工人B，A每天能搬1000块转，B每天最多能搬1500块，在搬砖方面，优秀和普通的差别最多50%。码农也经常自嘲自己搬砖，但是在效率上普通和优秀之间的差距非常大，是几倍、十倍、甚至是可能和不可能的差距。优秀的码农总是看起来很轻松，并且有较多的思考时间，原因是他总能较快的完成任务。如何高效率不在本文的讨论范围，但是管理者必须注意到这个现象，并进行区别。
6，快速解决线上问题
常在岸边走，哪能不湿鞋。线上故障对于开发是家常便饭，线上故障紧急且紧张，这个氛围中谁能快速找到原因并给出解决办法，绝对是大家心目中的英雄。能快速解决问题的人，一定是对代码和业务最熟悉的人，也是善于利用各种工具的人。
7，主动担当
这一点是很多技术性码农不具备，技术性码农很多时候更愿意去承担技术相关的问题，提升自己的技术。实际工作中，总有很多业务问题要解决，也总有一些突发的问题要解决。优秀的码农总能自己跳出来并承担，完成业务目标并得到上级的认同，也能在职场中走的更远。
8，善于交流和分享
优秀的码农绝不是“木讷、呆板”的普通人中的形象；且且想反，优秀的码农都是EQ较高，并且善于表达自己的观点，分享自己的经验。在团队中、在业界发挥着自己的影响力，同时自己得到更快速的提升。
https://bravenewgeek.com/shit-rolls-downhill/
Post-mortem debriefings every day are littered with the artifacts of people insisting, the second before an outage, that “I don’t have to care about that.”
If “abstracting away” is nothing for you but a euphemism for “Not my job,” “I don’t care about that,” or “I’m not interested in that,” I think Etsy might not be the place for you. Because when things break, when things don’t behave the way they’re expected to, you can’t hold up your arms and say “Not my problem.” That’s what I could call “covering your ass” engineering
Abstraction is not about boundaries of concern, it’s about boundaries of focus. Engineers need to have an intimate understanding of this.
But engineering is more than just technical aptitude and a willingness to “dig in” to the guts of something. It’s about having an acute awareness of the delicate structure upon which software is built. More succinctly, it’s about having empathy. It’s recognizing the fact that shit rolls downhill.
Essentially, too much emphasis can be placed on the current or perceived needs of the customer, resulting in a failure to meet their unstated or future needs (or if we’re talking about internal customers, the current or future needs of the business). Furthermore, we can spend too much time focusing on the customer’s needs—often perceived needs—culminating in a paralysis to ship. This is very anti-continuous-delivery. Get things out fast, see where they land, and make appropriate adjustments on the fly.
Giving in to customer demands is a judgement game, but depending on the demand, it can have profound impact on the people further down the hill. Thus, these decisions should be made accordingly and in a way that involves a cross section of the hill. If someone near the top is calling all the shots, things are not going to work out, and in all likelihood, someone else is going to end up getting covered in shit.
Set Appropriate Expectations
If the team you depend on is lagging, you might not have the same liberty. This leads to the dangerous “us versus them” trap teams fall in as an organization grows. The larger a company gets, the more fingers get pointed because “they’re no longer us, they’re them.” There are more teams, they are more isolated, and there are more dependencies. It doesn’t matter how great your culture is, changing human nature is hard. And when pressure builds from above, the finger-pointing only intensifies.
Therefore, it’s critical to align yourself with the teams you depend on. Likewise, align yourself with the teams that depend on you, don’t alienate them. In part, this means have a realistic sense of urgency, have realistic expectations, and plan accordingly
Speak with the team you depend on, understand where your needs fit within their current priorities, and if it’s a risk, be willing to roll up your sleeves and help out
While it’s important to set appropriate expectations downward, it’s also important to communicate upward. Ensure that the teams relying on you have the correct expectations. Establish what the team’s short-term and long-term goals are and make them publicly available. Enable those teams to plan accordingly, and empower them so that they can help out when needed. Provide adequate documentation such that another engineer can jump in at any time with minimal handoff.
Be Curious
Being an engineer should mean having an innate curiosity. Figure out what you don’t know and push beyond it.
Understand, at least on some level, the things that you depend on. Own everything. Similarly, if you built it and it’s running in production, it’s on you to support it. Throwing code over the wall is no longer acceptable. When there’s a problem with something you depend on, don’t just throw up your hands and say “not my problem.” Investigate it. If you’re certain it’s a problem in someone else’s system, bring it to them and help root cause it. Provide context. When did it start happening? What were the related events? What were the effects? Don’t just send an error message from the logs.
one reason that many soaring young companies flame out after an IPO based on a single hot product is that their initial success is grounded in resources—often the founding engineers—and they fail to develop processes that can create a sequence of hot products
https://www.kitchensoap.com/2012/10/25/on-being-a-senior-engineer
In order not to confuse titles with expectations that are fuzzy, sometimes I’ll refer to engineering maturity.
Meaning: I expect a “senior” engineer to be a mature engineer.
I’m going to gloss over the part where one could simply list the technical areas in which a mature engineer should have some level of mastery or understanding (such as “Networking”, “Filesystems”, “Algorithms”, etc.) and instead highlight the personal characteristics that in my mind give me indication that someone can influence an organization or a business positively in the domain of engineering.
Mature engineers seek out constructive criticism of their designs.
Every successful engineer I’ve met, upon finishing up a design or getting ready for a project, will continually ask their peers questions along the lines of:
- “What could I be missing?”
- “How will this not work?”
- “Will you please shoot as many holes as possible into my thinking on this?”
- “Even if it’s technically sound, is it understandable enough for the rest of the organization to operate, troubleshoot, and extend it?”
This is because they know that nothing they make will ever only be in their hands, and that good peer review is what makes better design decisions. As it’s been said elsewhere, they “beg for the bad news.”
Mature engineers understand the non-technical areas of how they are perceived.
Nothing indicates that you have a lack of perspective and awareness like a poorly thought out and nonconstructive tweet that slings venomous insults. It’s a junior engineer mistake to toss insults about a piece of complex technology in 140 characters.
Mature engineers do not shy away from making estimates, and are always trying to get better at it.
Mature engineers have an innate sense of anticipation, even if they don’t know they do.
This code looks good, I’m proud of myself. I’ve asked other people to review it, and I’ve taken their feedback. Now: how long will it last before it’s rewritten? Once it’s in production, how will its execution affect resource usage? How much so I expect CPU/memory/disk/network to increase or decrease? Will others be able to understand this code? Am I making it as easy as I can for others to extend or introspect this work?
Mature engineers understand that not all of their projects are filled with rockstar-on-stage work.
Getting things done means doing things you might not be interested in. No matter how sexy a project is, there are always boring tasks. Tedious tasks. Tasks that a less mature engineer may deem beneath their dignity or their job title. My good friend Kellan Elliot-McCrea (Etsy’s CTO) had this to say about it:
“Sometimes the saving grace of a tedious task is their simplicity and maturity manifests in finishing them quickly and moving on. Sometimes tasks are tedious because they require extreme discipline and malleable attention span. It’s an odd phenomena that the most tedious tasks, only to be carried out by the most senior engineers, can also be the most terrifying.”
Mature engineers lift the skills and expertise of those around them.
“Teaching to fish” is a mandatory skill at this level, and that requires having both patience and a perspective of investment in the rest of the organization.
Ok, let’s work on this together. I can show you how I’m writing/troubleshooting/etc. Then, you do it so I can be sure you know why/how we’re doing it this way, etc
Mature engineers make their trade-offs explicit when making judgements and decisions.
They know that one cannot be both efficient and thorough at the same time (The ETTO Principle), that most projects engineers work on exist on an axis of optimality and brittleness, and that whether the problems they are solving are acute or chronic.
Later on in the lifecycle of a design, when the original design is not scaling anymore or needs to be replaced or rewritten, they can look back not with a perspective of how short-sighted those earlier decisions were, but instead say “yep, we made it this far with it and knew we’d have to extend or change it at some point. Looks like that time is now, let’s get to work!” instead of responding with a cranky-pants, passive-aggressive Hindsight Bias-filled remark with counterfactuals (e.g.. “those idiots didn’t do it right the first time!”, “they cut corners!”, “I TOLD them this wouldn’t work!”)
- “Premature optimization is the root of all evil.” – a very abused maxim, and I’ve written about it before. A corollary to that might be (taken from here) ‘Understanding what is and isn’t “premature” is what separates senior engineers from junior engineers.’
- “Right tool for the job” – another abused one. The intention here is reasonable: who wants to use a tool that isn’t appropriate? But a rare perspective is that this can be detrimental when taken to the extreme. A carpenter doesn’t arm himself with every variation and size of hammer that is available, even thought he may encounter hammering tasks that could be ideally handled by each one. Why? Because lugging around (and maintaining) a gazillion hammers incurs a cost. As such, decisions on this axis have trade-offs.
The tl;dr on trade-offs is that everyone cuts corners, in every project. Immature engineers discover them in hindsight, disgusted. Mature engineers spell them out at the onset of a project, accept them and recognize them as part of good engineering.
Mature engineers don’t practice CYAE (“Cover Your Ass Engineering”)
Mature engineers stand up and accept the responsibility given to them. If they find they don’t have the requisite authority to be held accountable for their work, they seek out ways to rectify that.
An example of CYAE is “It’s not my fault. They broke it, they used it wrong. I built it to spec, I can’t be held responsible for their mistakes or improper specification.”
Mature engineers are empathetic.
mature engineers realize that those goals and views may be different. They understand this so that they can navigate effectively in the work that they do. Being empathetic in this sense means having the ability to view the project from another person’s perspective and to take that into consideration into your own work.
Goal conflicts are inherent in all engineering work, and complaining about them (instead of embracing them as requirements for success) is a sign of a less mature engineer.
They don’t make empty complaints.
Instead, they express judgements based on empirical evidence and bring with those judgements options for solving the problem which they’ve identified. A great manager of mine said to never go to your boss with a complaint about anything without at least one (ideally more than one) suggestion for a solution. Even demonstrating that you’ve tried working the problem on your own and came up empty-handed is better than an empty complaint.
Mature engineers are aware of cognitive biases
Culturally, engineers work day-to-day in empirical evidence in research. Basically: show me the data. The issue with cognitive biases is that we can be blissfully unaware of when we are interpreting data with our own brains in ways that defy empirical data, and can have a surprising effect on how we get work done and work on teams.
- Self-Serving Bias – basically: if something is good, it’s probably because of something I did or thought of. If it’s bad, it’s probably the doing of someone else.
- Fundamental Attribution Error – basically: the bad results that someone else got from his work must have something to do with how he is, personally (stupid, clumsy, sloppy, etc.) whereas if I get bad results, it’s because of the context that I was in, the pressure I was under, the situation I was in, etc.
- Hindsight Bias – (it is said that this is the most-studied phenomenon in the history of modern psychology) basically: after an untoward or negative event (a severe bug, an outage, etc.) “I knew it all along!”. It is the very strong tendency to view the past more simply than it was in reality. You can tell there is Hindsight Bias going on when descriptions involve counterfactuals, or “…they should have…”, or “…how did they not see that, it’s so obvious!”.
- Outcome Bias – like above, this comes up after a surprising or negative event. If the event was very damaging, expensive to clean up, or severe, then the decisions or actions that contributed to that event are judged to be very stupid, reckless, or negligent. The judgement is proportional to how severe the event was.
- Planning Fallacy – (related to the point about making estimates under uncertainty, above) basically: being more optimistic about forecasting the time a particular project will take.
The Ten Commandments of Egoless Programming
- Understand and accept that you will make mistakes. The point is to find them early, before they make it into production. Fortunately, except for the few of us developing rocket guidance software at JPL, mistakes are rarely fatal in our industry. We can, and should, learn, laugh, and move on.
- You are not your code. Remember that the entire point of a review is to find problems, and problems will be found. Don’t take it personally when one is uncovered. (Allspaw note – related: see below, number #10, and the points Theo made above.)
- No matter how much “karate” you know, someone else will always know more. Such an individual can teach you some new moves if you ask. Seek and accept input from others, especially when you think it’s not needed.
- Don’t rewrite code without consultation. There’s a fine line between “fixing code” and “rewriting code.” Know the difference, and pursue stylistic changes within the framework of a code review, not as a lone enforcer.
- Treat people who know less than you with respect, deference, and patience. Non-technical people who deal with developers on a regular basis almost universally hold the opinion that we are prima donnas at best and crybabies at worst. Don’t reinforce this stereotype with anger and impatience.
- The only constant in the world is change. Be open to it and accept it with a smile. Look at each change to your requirements, platform, or tool as a new challenge, rather than some serious inconvenience to be fought.
- The only true authority stems from knowledge, not from position. Knowledge engenders authority, and authority engenders respect – so if you want respect in an egoless environment, cultivate knowledge.
- Fight for what you believe, but gracefully accept defeat. Understand that sometimes your ideas will be overruled. Even if you are right, don’t take revenge or say “I told you so.” Never make your dearly departed idea a martyr or rallying cry.
- Don’t be “the coder in the corner.” Don’t be the person in the dark office emerging only for soda. The coder in the corner is out of sight, out of touch, and out of control. This person has no voice in an open, collaborative environment. Get involved in conversations, and be a participant in your office community.
- Critique code instead of people – be kind to the coder, not to the code. As much as possible, make all of your comments positive and oriented to improving the code. Relate comments to local standards, program specs, increased performance, etc.
Dirty secret: mature engineers know the importance of (sometimes irrational) feelings people have. (gasp!)
“It is amazing what you can accomplish if you do not care who gets credit.”
http://muratbuffalo.blogspot.com/2018/02/think-before-you-code.htmlThink before you code
Always think
http://blog.cleancoder.com/uncle-bob/2015/11/18/TheProgrammersOath.html
I will not produce harmful code.
The code that I produce will always be my best work. I will not knowingly allow code that is defective either in behavior or structure to accumulate.
I will produce, with each release, a quick, sure, and repeatable proof that every element of the code works as it should.
I will make frequent, small, releases so that I do not impede the progress of others.
I will fearlessly and relentlessly improve my creations at every opportunity. I will never degrade them.
I will do all that I can to keep the productivity of myself, and others, as high as possible. I will do nothing that decreases that productivity.
I will continuously ensure that others can cover for me, and that I can cover for them.
I will produce estimates that are honest both in magnitude and precision. I will not make promises without certainty.
I will never stop learning and improving my craft.
https://www.amazon.com/Becoming-Better-Programmer-Handbook-People/dp/1491905530/
From caring comes courage.
To write good code, you have to care about it. To become a better programmer you must invest time and effort.
In any coding situation, you refuse to hack something that only seems to work. You strive to craft elegant code that is clearly correct (and has good tests to show that it is correct).
You write code that reveals intent (that other programmers can easily pick up and understand), that is maintainable (that you, or other programmers, will be able to easily modify in the future), and that is correct (you take all steps possible to determine that you have solved the problem, not just made it look like the program works).
You work well alongside other programmers.
You consider other programmers, and construct code that others can read. You want the team to write the best software possible
Any time you touch a piece of code, you strive to leave it better than you found it (better structured, better tested, and more understandable…).
Keeping Up Appearances
Code
- Communication and maintenance
STRUCTURE WELL
Do not insert blank lines unless there is a natural “paragraph” break. This technique helps to emphasise flow and structure.
The order of code revelation is important. Consider the reader: put the most important information first, not last.
Ensure APIs read in a sensible order. Put what a reader cares about at the top of your class definition. That is, all public information comes before private information.
Don’t write one function with five “paragraphs.”
CONSISTENCY
AVOID REDUNDANCY
class WidgetList
public int numberOfWidgets() { ... }
he context of the enclosing class clearly defines what size means in this case.
Avoid redundant words.
BE CLEAR
Favor clarity over brevity.
BE IDIOMATIC
BE ACCURATE
Write Less Code!
compact/clean code
Cut through the waffle and say things clearly, but succinctly.
Express code clearly and succinctly. Avoid unnecessarily long-winded statements.
Dead code
Functions that are never called
Variables that are written but never read
Parameters passed to an internal method that are never used
Enums, structs, classes, or interfaces that are never used
Verbosity
A lot of code is needlessly chatty.
Clean up after yourself. As you work on a piece of code, remove all of the unnecessary code that you encounter.
Every day, leave your code a little better than it was. Remove redundancy and duplication as you find it.
YAGNI:
even code you think is going to be needed in future versions. Don’t write it now if you don’t need it now. Wait until you do have a genuine need.
It was easier to just implement it now, rather than go back to the customer to see whether it was really required. (Hint: It always takes longer to write and to maintain extra code. And the customer is actually quite approachable. A small extra bit of code snowballs over time to a large piece of work that needs maintenance.)
Looking back over your old code is like a code review for yourself. It’s a valuable exercise; perhaps you should take a quick tour through some of your old work. Do you like the way you used to program? How much have you learnt since then?
Finding old code that no longer feels “right” is a good thing: it shows that you have learnt and improved.
Your best route into code is to be led by someone who already knows the terrain. Don’t be afraid to ask for help!
test - usage pattern
how its going to be used
The best way to learn code is to modify it. Then learn from your mistakes.
DOCUMENT WHAT YOU FIND
If you can, enjoy the chance to tidy. It can be very rewarding to bring structure and sanity to a mess. Rather than see it as a tedious exercise, look at it as a chance to introduce higher quality.
Treat it as a lesson. Learn. How will you avoid repeating these same coding mistakes yourself?
Check your attitude as you make improvements. You might think that you know better than the original author. But do you always know better?
Don’t Ignore That Error
Consider all potential code paths as you write your code. Do not plan to handle “unusual” cases later: you’ll forget and your code will be buggy.
Your primary goal: Add value to others
Chapter 26. Don’t be afraid to look like an idiot
Learning how to learn: How to teach yourself
you have to learn how to swallow your pride and get out there and not be afraid to make a fool of yourself.
TAKE SMALL STEPS (OR DIVE RIGHT IN)
http://www.toastmasters.org/
Don’t copy code you find on the Web into your project without carefully inspecting it first.
Is the code genuinely completely correct? Does it handle all errors properly, or was it only illustrative?
Is it the best way to achieve what you need? Is it an out-of-date example? Does it come from a really old blog post, containing anachronistic code?
Focus on constructing the simplest code that satisfies the requirements right now. Write only what’s needed, and create the smallest, most appropriate API possible.
Promote and Refactor
As soon as you realise that it needs to be used in more than one place, refactor: create a shared library or a shared code file. Move the code in there. Extend the API as little as possible to accommodate the second user.
Accountability
Accountability Counts
Being accountable to other programmers for the quality of your work will dramatically improve the quality of your coding.
Realise that actively putting yourself into the vulnerable position of accountability is not a sign of weakness, but a valuable way to gain feedback and improve your skills.
If you know that someone else will read and comment on your code, you’re more likely to write good code.
Who should be the arbiter of your work quality? Who really knows how well you’ve performed? How can you get them involved? Is it as simple as asking them?
Don’t send someone an email when you need an urgent answer; email can sit ignored for days. Walk over to them, ring them, Skype them. Conversely, don’t phone someone for a non-urgent issue
Master the different forms of communication. Use the appropriate mechanism for each conversation.
Learn. Constantly.
Seek to improve. Constantly. (Yourself, your team, and your code.)
Always deliver value, considering the long term.
How can you quickly recognise when a developer is not performing as diligently as she should?
How can you be sure that you’re not adopting sloppy practices yourself? How can you prevent yourself from slipping into bad practices in the future?
Be diligent, be conscientious, and be professional
learn to collaborate
Purposefully place yourself beside excellent programmers.
Speak Up! Learn to communicate well; listening is essential if you are to learn.
Concentrate effort on the most important things first. What is most urgent, or will produce the most value?
MAKE IT SOMEONE ELSE’S PROBLEM
但其实，成为软件艺术家的意义不在于如何量化这些东西，而在于持续改进。在设计一个项目时，应该问自己：这个项目可以设计得更好吗？在代码通过测试之后，也可以问自己：代码的结构看起来够优雅吗？敢不敢拿它与你见过的最好看的艺术品做一番比较？
程序员在完成设计或写完代码之后一般不会想着怎么去改进，但艺术家会。这是程序员和软件艺术家之间最大的区别。程序员不一定都很糟糕，他们也能写出很好的代码、做出很好的设计，但一旦停下了追求的脚步，他们就无法成为艺术家。
https://www.quora.com/What-are-the-top-10-pieces-of-career-advice-Gayle-Laakmann-McDowell-would-give-to-future-software-engineersCode a lot
#2: Be language agnostic. Language is just a tool. It's valuable to know a language deeply, but it's also valuable to be learning new things. The best developers tend not to identify as a ____ developer.
#10: Be helpful. When possible, help people who ask for help. This is a nice thing to do as well as a smart thing to do. These people who ask you for help right now will be much more likely to help you in the future. That "help" might be introducing you to their friends who can help you more directly. So even if you don't see how that person will be helpful, you don't know who their buddies are or will be.
#11: Make friends. You actually can't really be successful by yourself. If you're an entrepreneur, you need employees and business connections. If you're an employee, you need a job. Either way, it's friends who will be key to opening up these opportunities. It's friends, distant and close ones, who form the important part of your network, not that one person you met at a meetup and never talked to again.
#13: Start stuff. Show initiative. Good things come to those who don't wait. Seek out new opportunities. Start stuff - a hackathon, a club, a project, a company, a new running group, whatever. You will learn so much from doing this and it will open doors.
#14: Take risks. Seize opportunities. When you notice that little flicker of opportunity, seize it. Run with it. See where it goes. Don't walk away just because you don't know exactly where it's going to go.
#15: Bias towards "yes." A great career hinges on the "breakthrough" moments. The problem is that you often can't identify those in advance. You don't know where that coffee meeting that you don't see the point in is going to lead. You won't know that, two months down the line, that person will end up introducing you to a guy who needs some advice and winds up as your business partner. Maintain a strong bias towards saying yes.
http://prog21.dadgum.com/87.html
http://www.techug.com/write-code-like-you-just-learned-how-to-program
It's extremely difficult to be simultaneously concerned with the end-user experience of whatever it is that you're building and the architecture of the program that delivers that experience. Maybe impossible. I think the only way to pull it off is to simply not care about the latter. Write comically straightforward code, as if you just learned to program, and go out of your way avoid wearing any kind of software engineering hat--unless what you really want to be is a software engineer, and not the designer of an experience.
http://www.phpxs.com/post/4582
真正的编程能力
编程能力是一种解决问题的能力
如果问题没能被很好地解决，知道再多也没用。
编程能力是一种运用机器解决问题的能力
编程能力是一种抽象问题的能力
借用轮子是很好的办法，省力省时间。今天任何软件工程师都会有意无意地使用很多轮子，从操作系统编译器数据库网络到算法数据结构。想高效地借用轮子，就需要将问题分解再分解，抽象再抽象。任何一个实用的系统（不包括教科书上的示例程序和简单的脚本程序）都需要进行大量的分拆和组合。所以系统设计是编程能力里的高级技能，加合理的假设简化问题尤其有难度，此处不展开讨论。高手和新手的区别在于新手往往不知道轮子的适用范围，而高手的手上轮子数量多且熟知各种轮子的差异，所以对不同的问题可以轻松地找到合适的轮子，当实在找不到合适的轮子时可以自己动手改造现有的轮子。平时有时间拆装和改造已有的轮子会对水平提升有较大帮助。当然能知道怎样快速在搜索引擎里搜出轮子也是一种能力。
编程能力是一种需要考虑扩展性的能力
编程能力是一种取舍的能力
局部的最优解未必是全局的最优解。如果一个美妙的解决方案需要将完工时间向后推迟一两个月，需要考虑是否先使用平凡方案解决问题，之后再进行优化。当你的工作延后会阻碍别人的工作时尤其如此。发现一个绝妙的优化方案时先想想这个优化是否真的有价值，如果只是系统中很小的部分，那么不要为了追求心理满足而花很多时间放一个漂亮的轮子上去（参考Amdahl定律）。
编程能力是一种预见未来的能力
目前的方案有哪些假设和局限性，在何种情形下会遇到问题甚至崩溃。在未来出现问题时问题是否需要重新定义，系统是否需要重新设计，代码是否需要重构或优化等等都需要未雨绸缪。
http://www.csdn.net/article/2014-04-16/2819338-Programmer-Learning
多读经典书
2. 国内外高手写的实战类图书。这类书实战性很强，将技术及原理讲得很透彻。比如《Windows环境下32位汇编语言程序设计》、《深入解析MFC》、 《Delphi深度探索》、《深入浅出WPF》、《深入剖析ASP .NET组件设计》等。以前这类书都是从国外翻译或从台湾引进的，现在国内高手越来越多，出自国内作者的图书也越来越多。如果能在学习的每个方向看两三本 这类图书，并通过实践消化掉，那么毫无疑问，你会成为一名优秀的程序员。
3. 国外大牛写的揭露本质、有丰富思想的书。这类书就是所谓的经典书，例如《代码大全》、《编程珠玑》、《设计模式》、《重构》、《代码整洁之道》等。经典书 就像一个有深度、有思想的朋友，能给你启发，每次阅读都会有新的收获，这类书具有真正的收藏价值。看经典书永远是正确的选择，它绝不会浪费你的时间，因为 经典书是无数人沙里淘金、帮你挑选出的结果。
不要在上班时间看书一个善于学习的人，首先要善于利用一切时间来学习。
上班时间看书，不但是一件很敏感的事情，而且非常吸引眼球，很快就会引起周遭的不爽。首先老板心里不爽：“我给你钱是让你来工作的，不是来学习的”；其次同事们也不爽：“我们工作都做不完，瞧，这小子真闲啊”。用不了多久，你就会成为被众人排斥的异类，这最终会让你自己“很受伤”。
要高效学习
只学习与工作相关的东西
最实际的方向，应该跟着工作走，工作需要什么，我们就学什么，把工作需要的技能熟练掌握，有很多好处。
其次，可以学得更快、更深入，因为学习更具有针对性，而且可以立即在工作中运用，可以马上检验出学习的效果。对存在的问题进行深入研究，掌握的知识也会更加牢固。
当我们把学习的焦点放到与工作相关的知识上时，工作时间中的很大一部分，同时也就成了宝贵的学习时间，这真是一举两得的美事啊。
问题是最好的学习机会
“工作就是不断发现问题、分析问题、最终解决问题的过程，晋升之门将永远为那些随时解决问题的人敞开着。
问题其实是最好的学习机会。往往那些愿意接受困难工作的人，能力会越来越强，那就是因为他们在克服困难的过程中取得了巨大的进步。
织网式学习
知识的广度和深度都很重要。作为一名程序员，能深入把握技术细节，是写出优质代码的保证。但对于一名项目经理而言，知识的广度更显重要。项目中碰到的问题往 往具有综合性，只有具备广博的知识，才能快速对问题进行分析和定位。在程序员成长的道路上，我们必须有意识地扩大自己的知识面，形成更完善的知识体系。
经常思考总结
子曰：“学而不思则罔”。人只学习不思考，就会迷惑，难以把握事情的本质。
克服“高原现象”
爱学习的人都会有这样的经历：学习持续了一段时间之后，往往会有一个瓶颈期，长时间似乎都没有什么进步，于是内心非常着急。
高原期，实质是一个消化期。由于前期的学习积累了太多的知识点，这些知识点在大脑中乱作一团，还没有形成一个知识体系。这时需要一定的时间来消化它，让它融会贯通，经常思考总结可以快速帮你跨过高原期。
处于高原期时，还可以换一个相关的方向来学习。例如，编程语言学不下去了，可以学习一下设计模式，设计模式也学不下去了，再换成数据库。通过学习这些相关的知识，不但补齐了知识体系中的短板，而且各个知识点之间可以互相启发，帮助你实现顿悟，跨过高原期。
http://www.raychase.net/3529
打接口请求响应日志，竟然不知道用拦截器。
打错误日志竟然不打上下文信息，每个人一种日志风格，千奇百怪。
许多重要的中间流程，居然不打日志。
打错误日志竟然不打上下文信息，每个人一种日志风格，千奇百怪。
许多重要的中间流程，居然不打日志。
>> 拦截器是个好东西，简化代码，避免啰嗦的日志影响业务逻辑的阅读。当然也有不好的地方，比如不直观、不好调试，以及有时候可能发生的性能问题等等。因此这个也不强求，根据项目实际情况而定。日志风格千奇百怪的问题，多是由于缺乏项目内部的管理造成的，各就各业，缺少沟通。开发人员不怎么样不说，这个项目经理更是弱爆了。重要流程不打日志，这一条只能帮助证明这群开发人员的工程意识还欠缺。
所有服务间通讯，都没有设requestId，导致跟踪会话很困难。
一个运行了两年的项目，spring的包扫描明显配错了，有些bean根本扫不进来，居然没有人发现。
一半的bean在spring管理下，另一半的bean他们自己写单例模式来实例化。
一半的bean在spring管理下，另一半的bean他们自己写单例模式来实例化。
>> 第一条依然是项目组疏于管理的佐证。即便是主力程序员，也缺少对项目整体的责任感，或者是代码烂得让人难以提起兴致。第二条则是一个典型的不好的实践。有时候可能会需要这样的妥协，但是居然有一半的bean脱离Spring的管理，那最初引入Spring干嘛？
他们用mysql来做审计系统，出报表，有个报表要跑8分钟。
原来是有人用字符串来存多值（逗号分隔），sql里写了like，导致没有利用到索引。
为什么不用pg，pg在sql编程方面，功能更丰富，更适合做统计，它本身就支持数组。
原来是有人用字符串来存多值（逗号分隔），sql里写了like，导致没有利用到索引。
为什么不用pg，pg在sql编程方面，功能更丰富，更适合做统计，它本身就支持数组。
>> 报表跑8分钟很正常。Sql用字符串存多值这个，没有利用索引，还是要分析具体问题，原则上我不觉得有什么问题。要想完美解决这个问题，还是在mysql里面，就得把多值拆解成多行，放到一张新表里面去。另外，也有一些NoSQL系统天然支持value多值，比如DynamoDB，不过这是题外话。至于为什么不用pg，这涉及到最初的技术选型，后人看的时候只是说说“如果用xxx就yyy了”当然容易，但是不清楚最初是否有技术层面的考量。当然，这个项目那么烂，也许是一开始图方便搞了mysql的prototype就上了。无论如何，有质疑的想法总是值得鼓励的。
程序员们都是得过且过的态度，怎么把代码灌进去，跑的通测试，就算交差了。
Be well rounded.
Enjoy solving puzzles.
Love learning.
Good communication skills. Working as a developer isn’t just about technology. Developers need to talk with business users to understand what they need from the application. Developers also often need to generate technical documents, so being able to write clearly is also important—even if it’s just to produce a status report.
Confidence. There’s never just one way to build a system. No matter how good your ideas are, they won’t have value if you keep them to yourself. The best developers have confidence in their ideas and speak up in design discussions to help shape the application architecture. To boost your confidence, start with a small suggestion, rather than proposing an entire application redesign.
Be interested in the business. Businesses use technology to solve business problems. The more you understand about your company’s business, the better prepared you are to understand their problems and build solutions that help them grow. You should take advantage of opportunities to talk to the business users and ask them questions about the challenges they face in their work. If you get really interested in understanding the business, you can take courses or even work towards certifications in the business domain.
Be a team player.
Understand the importance of deadlines.
once you’ve agreed to do a task, do your best to meet the deadline, even if it means a few late nights. You don’t have to give up your whole personal life for the organization, but demonstrating commitment to completing the project and understanding its value to the business make a positive impression at work.
Be adaptable. Projects and priorities change for many reasons, and developers need to be able to context-switch to focus on what’s most important right now. The changes may be small and temporary or major and permanent. If they’re temporary, make sure you have good notes that will help you get back to your regular work when things settle down. If the changes are permanent, allow time to understand what the new situation is and how you fit into it. It may present new opportunities to help you achieve your goals. In any case, it’s important to respond professionally and not lash out in frustration.
Own your product.
// think how u can improve it, make it better etc.
Technically, your job may be done once you’ve written code that compiles cleanly and passes its test cases. Stand out by following it through the rest of its lifecycle—be willing to help with testing, deployment, training users, and solving production problems. While this helps your business, it actually helps you more, because you see and understand the real-world effectiveness of the code you wrote. Then take that understanding and let it help you make your next application even better.
http://javahungry.blogspot.com/2014/05/how-to-become-good-software-programmer.html
2. Fallacy of Knowing a Number of Programming Languages
3. Studying Books
4. Base of Algorithm
5. Practising Data Structures and Design Related Problems
6. Talking to Experts in the Field
7. Reading Good Blogs and Participating in Coding Communities
http://www.alexparker.me/you-know-nothing-about-code/
What I did right?
- I never stressed or compared myself to those far beyond my level. I just focused on what I knew, how I could use it, and what I wanted to know.
- I tried to find ways to apply new knowledge to current projects. Or create a project around the new knowledge.
- I always tried to solve problems I felt were just outside my reach from what I already knew, and not too much more.
- I enjoyed the journey along the way, not having an end in mind.
- I learned to love the learning process.
What I did wrong?
- A lot.
- I didn't have any friends that shared the same interest.
- I didn't find a community or group that I could join and learn together.
- I didn't read books earlier.
- I didn't contribute to open source more.
First things first, admit and be aware of the things we don't know. Embrace them as opportunities and not as faults.
Start simple and do what sounds fun. Make it a hobby and try not to plan too far in the future as you are learning. Learn to love to learn and enjoy the process.
Keep learning projects realistic, but difficult enough to enable you to grow.
http://www.infoq.com/cn/news/2013/02/howto-strong-developer
http://www.aaronstannard.com/10-reasons-why-youe28099re-failing-to-realize-your-potential-as-a-developer/
You’re too afraid of failure to learn new tools / languages / frameworks.
Strong developers embrace the challenge and opportunity to learn new ways of doing things.
You won’t push your commits until the feature is “done.” (It’s never done!)
Strong developers recognize that they are not their code, and thus will put code out in front of the rest of the team more frequently and take criticism and suggestions with dignity and confidence.
You know just enough to be dangerous.
Good developers not only know what something does, but they seek to understand why it was done this way and under what conditions it should be used.
Analysis paralysis.
Strong developers who are in unfamiliar territory don’t care – they’ll write shit code, unit test it, and throw it away in 45 minutes if they don’t think it can get the job done. Strong developers actively limit the amount of time they spend researching, because they recognize that it’s a trap – it feels like work but often isn’t.
You don’t invest in your tools or development process.
You’re too embarrassed to ask for help.
You don’t know how to make it easy for other programmers to work with your code.
You don’t know how to read someone else’s code (or don’t want to.)
Reading code is harder than writing code, but strong developers invest time into learning how to excel at it.
You can’t code from the end-user’s point of view (you think too small.)
As a programmer, you job isn’t really to solve technical problems – you solve technical problems in order to solve business problems.
Average developers don’t anticipate other related use cases; don’t think about the end-user’s experience; and basically have to be managed heavily when working on anything user-facing. This is why so many of them get stuck writing line of business apps instead of products.
You aren’t able to judge the business value of any programming task.
The highest cost of any engineering team is development time, and average developers waste lots of it on minutia and technical tasks that are ultimately low business value.
http://bloggingpool.com/6-ways-to-become-a-professional-programmer/http://www.aaronstannard.com/10-reasons-why-youe28099re-failing-to-realize-your-potential-as-a-developer/
You’re too afraid of failure to learn new tools / languages / frameworks.
Strong developers embrace the challenge and opportunity to learn new ways of doing things.
You won’t push your commits until the feature is “done.” (It’s never done!)
Strong developers recognize that they are not their code, and thus will put code out in front of the rest of the team more frequently and take criticism and suggestions with dignity and confidence.
You know just enough to be dangerous.
Good developers not only know what something does, but they seek to understand why it was done this way and under what conditions it should be used.
Analysis paralysis.
Strong developers who are in unfamiliar territory don’t care – they’ll write shit code, unit test it, and throw it away in 45 minutes if they don’t think it can get the job done. Strong developers actively limit the amount of time they spend researching, because they recognize that it’s a trap – it feels like work but often isn’t.
You don’t invest in your tools or development process.
You’re too embarrassed to ask for help.
You don’t know how to make it easy for other programmers to work with your code.
You don’t know how to read someone else’s code (or don’t want to.)
Reading code is harder than writing code, but strong developers invest time into learning how to excel at it.
You can’t code from the end-user’s point of view (you think too small.)
As a programmer, you job isn’t really to solve technical problems – you solve technical problems in order to solve business problems.
Average developers don’t anticipate other related use cases; don’t think about the end-user’s experience; and basically have to be managed heavily when working on anything user-facing. This is why so many of them get stuck writing line of business apps instead of products.
You aren’t able to judge the business value of any programming task.
The highest cost of any engineering team is development time, and average developers waste lots of it on minutia and technical tasks that are ultimately low business value.
3. Don’t Be Afraid to Break Things
4. The Professional Programmer
The single most important trait of a professional programmer is personal responsibility. Professional programmers take responsibility for their career, their estimates, their schedule commitments, their mistakes, and their workmanship. A professional programmer does not pass that responsibility off on others.
If you are a professional, then you are responsible for your own career.
http://pythonpracticeprojects.com/how-benjamin-franklin-learned-to-program.html
The Benjamin Franklin Programming Practice Model
- Find a program that you greatly admire and read it.
- Takes note on the roles, inputs, and outputs of each major component.
- Take notes on how the components interact.
- Rewrite the program.
- Compare your code with the original.
- Note where you can improve and study acccordingly.
Don't just write more programs. Super charge your abilities by studying great programs, and then trying to imitate them.
http://devbanter.com/2015/10/08/how-to-recover-from-programmers-burnout/Eat a hearty breakfast
Drink water
http://blog.jobbole.com/72699/
1. 解析问题，手工“解决”
2. 想出一个伪代码算法
3. 将算法转换为代码
1. 不停练习，直到你能快速且正确地写出小的代码片段。没有任何理由用自己喜欢的语言写不出一个双循环。找一些带有例子的小的代码智力题，你能在一分钟以内理解这些问题。对这类问题做成百上千遍的练习（不仅仅是几十遍，切记！）。
2. 为课本上的每个算法写一个用例列表。一个共同的错误就是仅仅记住计算复杂度表。但是看一些算法的使用例子，例如 A*搜索在哪些地方使用，这比学习代码本身要有用的多。
3. 至少做一个能逼迫你使用与工作相关的接口/用例的大型项目。语言通常不是很重要，而且独自写一个大型工程能够强迫你去学新的设计模式以及远离遗留代码维护。代码面试是智利测试。所以它们很少关注具体的体系。
4. 让自己接触更优秀的程序员
第 1 个一点点：专注眼下
第 2 个一点点：思考力与推动力
我认为处理bug、崩溃、调优、入侵等突发事件比编程本身更能体现平庸程序员与理想程序员的差距。当面对一个未知的问题时，如何定位复杂条件下的核心问题、如何抽丝剥茧地分析问题的潜在原因、如何排除干扰还原一个最小的可验证场景、如何抓住关键数据验证自己的猜测与实验，都是体现程序员思考力的最好场景。是的，在衡量理想程序员的标准上，思考力比经验更加重要。
理想的程序员永远不会等事情前进，他们会用尽一切方法让事情前进。
第 3 个一点点：Never Say No
第 4 个一点点：投资未来
第 5 个一点点：善用工具
善用工具可以分为 4 个层面：
搜索引擎
不相信重复
代码片段
自动化
理想的程序员会着力找寻有效的资料保存方式，把工作里灵光闪现写下的代码、脚本、配置、 经验等短的片段保存起来，以便任何时候都能复查。
理想的程序员必须懒惰。对他们来说，重复的步骤和重复的代码一样丑陋，如果意识到一项工作有可能长期要重复，那么自动化的时间总是越早越好。
第 6 个一点点：管理时间
http://www.csdn.net/article/2015-10-25/2826034
仅仅做出决策是不够的，我们可以从时间线上来观察：在做出决策之前，架构师需要足够了解自己的“可选项”，无论是用户的实际需求，还是最新出现的技术和框架，并且都得要有足够深入的理解（否则就是在拍脑袋做决策）。这时，架构师的角色，是一个“研究者”。
在综合各项因素，甚至是相互矛盾的各种需求之后，在考虑到团队的实际能力与交付压力之后，在平衡了先进性与可靠性、扩展性与稳定性、重要性与紧迫性之后，架构师做出了一组决策。这时，架构师的角色，是一个“设计师”。
1. 以理解用户为荣，以想当然尔为耻
2. 以脚踏实地为荣，以夸夸其谈为耻
3. 以身先士卒为荣，以指手画脚为耻
4. 以实践检验为荣，以道听途说为耻
5. 以先见之明为荣，以后知后觉为耻
6. 以兼容并包为荣，以独断专行为耻
7. 以主动学习为荣，以固步自封为耻
8. 以勇猛精进为荣，以疏忽懈怠为耻
好学就能显得有智慧（至少能有知识），力行就能不脱离群众（因不忘本而能具备仁慈之心），知耻就能守底线（有所为有所不为之勇）
Engineers are hired to create business value, not to program things
You are not defined by your chosen software stack
Co-workers and bosses are not usually your friends
but in general, you will move on in three years and aside from maintaining cordial relations you will not go out of your way to invite them over to dinner. They will treat you in exactly the same way. You should be a good person to everyone you meet — it is the moral thing to do, and as a sidenote will really help your networking — but do not be under the delusion that everyone is your friend.
People who are skilled in negotiation make more than those who are not.
You are not defined by your chosen software stack
Co-workers and bosses are not usually your friends
but in general, you will move on in three years and aside from maintaining cordial relations you will not go out of your way to invite them over to dinner. They will treat you in exactly the same way. You should be a good person to everyone you meet — it is the moral thing to do, and as a sidenote will really help your networking — but do not be under the delusion that everyone is your friend.
People who are skilled in negotiation make more than those who are not.
archive all the personal code that they write, no matter the language or subject. Put it somewhere safe (ie. git/svn) and keep it as long as you can. Then once a couple of years have passed, take some time to look at it. There is nothing more gratifying than looking at some old code and thinking: “OMG my code was so stinking awful!!”, nothing more satisfying than executing old handmade programs and games.
You never realize how much improvement you’ve made as a coder until you’ve looked at yourself as a coder a few years back. It lets you become the user of your own creations, and it usually brings back some fond memories.
Your old code shows your creativity, your weaknesses, your strengths, your evolution and your improvements. It helps you stay humble and patient towards others coders. It’s your history in the byte world. It is precious. I urge you to keep it safe.
http://www.jianshu.com/p/167214b9d1bfhttps://www.quora.com/What-is-the-best-career-advice-for-a-software-developer-to-earn-higher-salary
Invest in skill sets that will pay. No use learning something just because you like it. Learn something for which companies are willing to pay top dollar.
Look at your colleagues who are 10+ years older than you and ask yourself if you wanna be doing the same stuff they are doing today. If the answer is no, find out what you need to do differently so as not to land in the same position as theirs ten years from now.
Make Computer Science fundamentals very strong , mainly DataStructure & Algorithm.
No point of being a master of single technology like Java or Python. Learn several technologies.It will broaden your skill-sets & thinking.
Heard any new technology, like BigData or Machine Learning. Make sure to understand that and implement a POC. Don't just read, make sure, you are very much aware of fundamentals
If you don't like your job or Manager don't react, keep smiling and keep working and look for new job. Never destroy your relationship with people
Blog about what you do. Write white papers on particularly innovative solutions you develop. Write about development best practices, your thoughts on languages and platforms, bug fixes, you name it. If you don't have a blog, you're missing out on the ability to walk into an interview with someone who knows more than just your resume, but also your development style and personality.
Find a problem that a lot of people struggle with that you can solve with your skill set. Write an open source solution, publish it, and maintain it. When you make updates, include the change log in your blog.
如何在大公司中成长
https://medium.com/swlh/busy-but-not-productive-94336103a2a1
Busy, but not productive
Unfortunately, for lots of startups, learning takes the form of doing something and then seeing what happens. That’s not learning. That’s just being busy. True learning requires asking a question and forming a hypothesis before taking action. That action (a test or an experiment) then helps you prove or disprove your hypothesis. In addition, most founders think about learning only in the context of their products. But being productive and focused on learning applies to every aspect of the business. Marketing, hiring, pricing, etc. all need to be hypothesis-driven so that you’re always learning about whether you’re targeting the right customer, hiring someone with the right experience or capturing the right value for your product.
1. Be a rubber ducky, find a rubber ducky
2. Get feedback fast
Mockups, designs on a whiteboard, etc. are a lot cheaper to throw out than hundreds of lines of code.
3. Get End-to-End first
I now have a feedback loop which helps me iterate and code faster. The design might not be perfect initially, but by seeing how things fit together, you get a clearer picture of the full system you're trying to design.
5. Automate
8. Read ahead
read ahead a bit and get more context. Programming concepts are difficult to express in a linear form. Reading ahead will often make it more clear what a previous sentence or code snippet is talking about.
9. Write meticulous notes
10. Plan for tomorrow, today
https://medium.com/@hilsoftinc/seven-habits-of-a-great-programmer-36682b736c83#.huihpqvzg
1. Good Time Management — Tardiness is one of the issues of any company.
2. Thorough Understanding on Customer Requirement — a single user story phrase is not enough. A great programmer should have the diligence to understand and decompose it into detailed technical tasks and/or sub tasks for the project to have a close to accurate estimates.
3. Full Algorithm before Coding — use cases, pseudo codes and flow charts are very vital in software development. A great programmer should not be so excited to code right away instead he or she should complete the algorithm first. Coding in effect will only just be an encoding task.
5. Exhausts All Resources — what if you’re dead end? A great programmer is a resourceful person. One who is able to ask its co-member, or team leader. One who is skillful in searching the internet and who has the patience to try and try. Surrendering will never be an option.
6. Diligent in Acknowledging Correspondences — soft skills are a common problem for us programmers as introverts. But a great programmer is aware of this weakness and should be able to have the initiative to improve oneself and execute customer service philosophies of the organization.
7. Proactive — a good programmer is more proactive than reactive. He or she should have the initiative and concern to improve processes and enhance software development productivity tools such as SVN, agile apps or anticipated software bugs.
A great programmer understands the business value of every tasks for one to feel authentic empathy in delivering any service.
http://henrikwarne.com/2015/04/16/lessons-learned-in-software-development/
1. Start small, then extend.
2. Change one thing at a time.
use short iterations. Do one thing, make sure it works, repeat. This applies down to the level of commits. If you have to refactor the code before you add a new feature, commit the refactoring first, then (in a new commit) add the new feature.
3. Add logging and error handling early.
4. All new lines must be executed at least once.
6. Everything takes longer than you think.
7. First understand the existing code.
before you can fit the new stuff in, you need to understand the current solution. Otherwise you may accidentally break some of the existing functionality. This is means that reading code is a skill that is as necessary as writing code. It is also part of the reason why seemingly small changes can still take a long time – you must understand the context in which you make the change.8. Read and run.
You can read the code, and you can run the code. Running the code can be a great help when figuring out what it does. Be sure to make use of both methods.
COOPERATION
15. Face to face has the highest bandwidth.
19. Try it. Explore how it works – fiddling around often reveals bugs, and at the same time it deepens your understanding of how the system works.
21. Change. Don’t be afraid to change roles or jobs every once in a while. It is stimulating to work with different people, on a different product or in a different company. In my view, too many people just passively stay at the same job year after year, only changing if they are forced to.
http://www.spencersutton.me/2015/11/15/dont-program-blind/
We programmers are doers by nature which is why I think this habit pops up from time to time. When we take minutes, hours, and sometimes even days to really understand the underlying problem in a system or codebase we feel like we are wasting our time. To a novice programmer, any time not programming is wasted time. To an experienced programmer, any time spent not fixing the problem is wasted time, and in this case, any time making the problem worse is one step lower than wasted time.
Next time you encounter a bug and before you try to fix it, think to yourself, do I understand what’s causing this with 100% certainty?
http://blog.teamtreehouse.com/what-makes-a-great-programmer
1. Good Time Management — Tardiness is one of the issues of any company.
2. Thorough Understanding on Customer Requirement — a single user story phrase is not enough. A great programmer should have the diligence to understand and decompose it into detailed technical tasks and/or sub tasks for the project to have a close to accurate estimates.
3. Full Algorithm before Coding — use cases, pseudo codes and flow charts are very vital in software development. A great programmer should not be so excited to code right away instead he or she should complete the algorithm first. Coding in effect will only just be an encoding task.
5. Exhausts All Resources — what if you’re dead end? A great programmer is a resourceful person. One who is able to ask its co-member, or team leader. One who is skillful in searching the internet and who has the patience to try and try. Surrendering will never be an option.
6. Diligent in Acknowledging Correspondences — soft skills are a common problem for us programmers as introverts. But a great programmer is aware of this weakness and should be able to have the initiative to improve oneself and execute customer service philosophies of the organization.
7. Proactive — a good programmer is more proactive than reactive. He or she should have the initiative and concern to improve processes and enhance software development productivity tools such as SVN, agile apps or anticipated software bugs.
A great programmer understands the business value of every tasks for one to feel authentic empathy in delivering any service.
http://henrikwarne.com/2015/04/16/lessons-learned-in-software-development/
1. Start small, then extend.
2. Change one thing at a time.
use short iterations. Do one thing, make sure it works, repeat. This applies down to the level of commits. If you have to refactor the code before you add a new feature, commit the refactoring first, then (in a new commit) add the new feature.
3. Add logging and error handling early.
4. All new lines must be executed at least once.
6. Everything takes longer than you think.
7. First understand the existing code.
before you can fit the new stuff in, you need to understand the current solution. Otherwise you may accidentally break some of the existing functionality. This is means that reading code is a skill that is as necessary as writing code. It is also part of the reason why seemingly small changes can still take a long time – you must understand the context in which you make the change.8. Read and run.
You can read the code, and you can run the code. Running the code can be a great help when figuring out what it does. Be sure to make use of both methods.
COOPERATION
15. Face to face has the highest bandwidth.
16. Rubber ducking. Whenever you are stuck, go to a colleague and explain the problem to them. Many times, as you talk, you realize what the problem is, even if your colleague doesn’t say a word. Sounds like magic, but works surprisingly often.
17. Ask. Reading and running the code is often great for figuring out what it does and how it works. But if you have the possibility to ask someone knowledgeable (perhaps the original author), use that option too. Being able to ask specific questions, and follow-up questions to those, can give you information in minutes that would otherwise take days to get.
18. Share credit. Make sure to give credit where credit is due. Say: “Marcus came up with the idea to try…” (if he did), instead of “we tried …”. Go out of your way to mention who else helped or contributed.
21. Change. Don’t be afraid to change roles or jobs every once in a while. It is stimulating to work with different people, on a different product or in a different company. In my view, too many people just passively stay at the same job year after year, only changing if they are forced to.
http://www.spencersutton.me/2015/11/15/dont-program-blind/
We programmers are doers by nature which is why I think this habit pops up from time to time. When we take minutes, hours, and sometimes even days to really understand the underlying problem in a system or codebase we feel like we are wasting our time. To a novice programmer, any time not programming is wasted time. To an experienced programmer, any time spent not fixing the problem is wasted time, and in this case, any time making the problem worse is one step lower than wasted time.
Next time you encounter a bug and before you try to fix it, think to yourself, do I understand what’s causing this with 100% certainty?
People First
Skillful at Problem Pattern Matching
http://netsmell.com/post/14-programming-tips.html1.如果性能不佳，就在应用层处理，别放在数据库层。
5.不些地方尽量不用注释，因为有时会适得其反。
7.遇到疑问时，和你的小伙伴积极讨论和沟通。
12.努力让自己更积极的面对工作，这样我们才能觉得有趣。
13.有时系统的崩溃仍是自己不原看到的，所以一定要做好日常的监控，记好监控日志，避免出现各种异常，保持系统对故障的敏感度和及时警报。
14.最后一点，要记得做好自己的本质工作，及时处理问题，做好相应对策。
http://www.cnblogs.com/codelove/p/4973334.html
能力和素质的提升往往是多方面的，而这些提升往往在于你做事的态度和习惯。好的习惯往往是好的态度下慢慢养成的。
对自我没有要求的程序员不是好程序员。
不要仅仅局限于开发方面的事物，能力是在多方面进行体现的。而且好的沟通能力以及开发文档编写能力也可以让你在开发方面走的更远，开发也更轻松。
有的人对自我要求很严格，眼里揉不下沙子，看见冗余代码就要重构，看见蹩脚代码就去想着改良，这习惯一形成，往往架构能力的成长就快得多。
有的人做事积极，做事情总是严格要求自己。比如需求设计表达清晰明确，框图、流程图都画的一丝不苟，各种Office文档玩得顺畅，那么其需求设计能力，文字组织能力会不断增强，如果沟通方面再加强锻炼，往项目管理或者产品经理方向发展是很有潜质的。
迅哥儿曾经说过，“哪里有天才，我只是把别人喝咖啡的时间用在学习上。”
- 时间不是别人给的，是自己挤出来的，只要懂得如何把握时间，时间就是自己的。
- 只有懂得把握时间的人才是天才
- 天才不是天生的，是时间积累出来的
- 工作之余的时间利用往往决定彼此的差距
http://www.jianshu.com/p/7645a5ea7f46
反复修改代码
提炼代码，减少冗余的习惯
如果你总是匆匆写出代码，却从来不回头去推敲，修改和提炼，你是不可能提高编程的水平的。你会制造出越来越多平庸甚至糟糕的代码。如果一个人有几十年的工作经验，却从来不回头去提炼代码，那么他也许还不如一个只有一两年经验，但是却反复推敲，仔细领悟的人。
代码是不可能一蹴而就的。灵感似乎总是零零星星，陆陆续续到来的。任何人都不可能一笔呵成，写成最优雅高效的代码。就算再厉害的程序员，也需要经过一段时间，才能发现最简单优雅的写法。
有时候你反复提炼一段代码，觉得到了顶峰了，没法再改进了。可是过了几个月之后再回头来看，又可以发现好多可以改进和简化的地方。这跟写文章一模一样，回头看几个月或者几年前写的东西，你几乎总是能发现可以改进的地方。所以如果反复提炼代码已经不再有进展，那么你可以暂时把它放下，过几个星期或者几个月再回头来看，也许就有焕然一新的感觉。
这样反反复复很多次之后，你就积累起了灵感和智慧，从而能够在遇到新的问题的时候直接朝正确，或者接近正确的方向前进。
- 先把眼前的问题解决掉，解决好，再考虑将来的扩展问题。
- 先写出可用的代码，反复推敲，再考虑是否需要重用的问题。
- 先写出可用，简单，明显没有bug的代码，再考虑测试的问题。
无懈可击地处理corner case
if (...) {
if (...) {
...
return false;
} else {
return true;
}
} else if (...) {
...
return false;
} else {
return true;
}
我的代码里，两个else分支都是
return true，所以他们觉得重复了。为了避免重复，他们省略掉那两个else分支，在最后使用一个return true。他们的代码看起来像这个样子：if (...) {
if (...) {
...
return false;
}
} else if (...) {
...
}
return true;
这种写法看似更加简洁，避免了重复，然而却很容易出现漏掉的情况。嵌套的if语句如果省略了一些else，是很难正确的分析和推理的。如果你的if条件里使用了
&&和||之类的逻辑运算，就更难看出是否涵盖了所有的情况。即使你看一会儿之后确信是正确的，每次读这段代码，你都不能确信它cover了所有的情况，你又得重新推理一遍。这简洁的写法，带来的是反复的头脑开销，所以到头来你会觉得很累。
使用有两个分支的if语句，只是我的代码可以轻松地达到无懈可击的其中一个原因。我写if语句的思路，其实包含了让代码可靠的一种通用的思想：穷举所有的情况，不漏掉任何一个。
如何对待和处理NULL指针尽量减少null指针的出现
- 不要把null放进任何复杂的数据结构里面。null不应该被放进List，不应该出现在Map的value里面。把null放进这些复杂的数据结构里，是一些莫名其妙错误的来源。如果你真要表示“没有”，那么你可以干脆不把它放进去（List没有元素，Map根本没那个key），或者你可以指定一个特殊的，合法的对象，用来表示“没有”。
- 尽早检查和处理null指针，尽量减少它的传递。
模块原则：写简单的，通过干净的接口可以被连接的部件。
清楚原则：清楚要比小聪明好。
合并原则：设计能被其它程序连接的程序。
分离原则：从机制分离从策略，从实现分离出接口。
简单原则：设计要简单；仅当你需要的时候才增加复杂性。
节俭原则：只有当被证实是清晰，其它什么也不做的时候，才写大的程序。
透明原则：为使检查和调试更容易而设计。
健壮原则：健壮性是透明和简单的追随者。
表现原则：把知识整理成资料，于是程序逻辑能变得易理解和精力充沛的。
意外原则：在接口设计中，总是做最小意外的事情。
沉默原则：一个程序令人吃惊什么也不说的时候，他应该就是什么也不说。
补救原则：当你必须失败的时候，尽可能快的吵闹地失败。
经济原则：程序员的时间是宝贵的；优先机器时间节约它。
产生原则：避免手工堆砌；当你可能的时候，编写可以写程序的程序。
优化原则：在雕琢之前先有原型；在你优化它之前，先让他可以运行。
差异原则：怀疑所有声称的“唯一真理”。
扩展原则：为将来做设计，因为它可能比你认为来的要快。
http://qwzs112.iteye.com/blog/2257896
http://blog.me115.com/2014/06/646
今天的计划完成的怎么样？
今天有哪些收获？
有什么经验可以总结下来，分享给大家？
我觉得这几件事处理的不错？
我觉得这几件事还可以处理的更好？
我觉得自己在这些方面可以做的更好?
今天做了哪些为自己人脉加分的事情？
今天微笑了么？
今天有没有控制好情绪？
今天虚度光阴了么？
今天有哪些收获？
有什么经验可以总结下来，分享给大家？
我觉得这几件事处理的不错？
我觉得这几件事还可以处理的更好？
我觉得自己在这些方面可以做的更好?
今天做了哪些为自己人脉加分的事情？
今天微笑了么？
今天有没有控制好情绪？
今天虚度光阴了么？
我的每日三问
我这个阶段的每日三问为：
计划：今天的时间利用都高效么？计划完成的怎么样？
改进：今天的哪些任务可以做的更好，可以改进？有没有可以自动化的项？（将改进项写入计划软件中）
收获：今天收获了什么？（可以整理出知识点或是blog么？）
http://www.jianshu.com/p/fdae559d1ed5计划：今天的时间利用都高效么？计划完成的怎么样？
改进：今天的哪些任务可以做的更好，可以改进？有没有可以自动化的项？（将改进项写入计划软件中）
收获：今天收获了什么？（可以整理出知识点或是blog么？）
2.代码结构，项目框架。不是学过一点OO的思想，按照直观判断划分出一坨class就叫代码结构。准确的模块切割需要考虑接口耦合性，继承关系，可维护性，尤其在多人协同开发的过程中，项目框架决定未来3个月后会不会听到此起彼伏的“这一块需要花几天重构”
3.设计模式，这一块很难讲好坏，很多人都只知道MVC设计模式，最多再加一个单例模式。这个东西属于学起来抽象无用，做起来没有相关知识做铺垫，写出来的就是一团毛线。
4.可阅读性。代码其实只是文本，用记事本写代码不只是传说。良好的编程素养能帮助程序员构建逻辑清晰的代码，一眼望去是一块一块而不是一坨一坨的。代码风格不只是编写习惯，更多体现一个程序员在编写代码过程中注重的细节程度。
1、不要试图一下子搞懂整个项目
2、关注于尽快交付价值
3、维护大型项目所必须的技能
3.1能够迅速发现需要的类
在任何维护活动中，无论是修复bug或增强功能，第一个动作就是识别出当前修复或增强的用例中调用的类。当你定位到需要修复或增强的类/方法，就已经完工了一半。
3.2能够分析变更的影响 当你在完成必要的修改或增强工作后，最重要的就是要确认你的修改没有破坏代码的其他部分。你要用你的java技术及对其他框架的理解找出变更可能影响的部分。
http://mindhacks.cn/2009/03/09/first-principles-of-programming/先弄清你的问题是什么！
弄清问题永远是问题解决过程中的第一步和最重要的一步。
代码只是工具，不是手段。
不知道怎么最好地解决你手头的问题（注：需求、架构、算法，技术选型，etc..），写上一万坨代码也是浪费比特。
知道什么时候不该编码。
（类似条目：YAGNI——“你并不需要编写这坨代码！”，针对你的需求编码，“写你所需”，别做“聪明事”，为一个不确定的未来编码。同时也注意模块化设计，以便能在未来新增需求时无痛扩充系统）
永远不要假定你已经了解一切了！
不作没有证据的推论。
想清楚了再编写。类似条目：如果方案在你脑子里面或者纸上不能工作，写成代码还是不能工作。
4. 一些众所很可能周知的答案：
http://blog.2baxb.me/archives/1077越懒越好。过早优化是一切罪恶的根源。不要重新发明轮子。测试通过前说什么“它可以工作”都是纯扯淡。了解你的工具。一切以用户需求为导向。利用分治、抽象，解开子问题之间的耦合。
- 为了工作，满足当前工作所必备的知识
- 为了提升，与当前工作相关的知识（深度）
- 拓展视野，与当前工作无关的知识（广度）
学习（1）之后只是个熟练工，2和3才是提升自己的途径，伴随着知识储备的提升，接触新事物时更容易找到相似的知识加以类比，加快理解，也更容易掌握本质。如果每天都在纠结“到底学什么”，那么只能说明还是学的太少了。（真正没什么可学的大牛们应该不会读到这里吧……）
所以，如果觉着没什么东西可以学的时候，那么可以考虑一下学一下更有深度的知识（比如虚拟机或编译器），或者完全不同的知识（新的语言或当前比较火的方向），甚至完全不相干的知识（单纯练习英文阅读，学习ppt排版之类）吧。随着知识储备增加，自己的不足和未来的学习的方向也会更加明确起来。
那么，如何向历史学习？
- 公司内部的资料库、wiki等大都会有旧时的资料，刚入职时大多不会太忙，这些资料库简直是挖不完的宝藏
- 部门内部分享，比如我当初入职时经常去听“微博XXXX架构演化历程”之类的内部分享
- 多问一下自己”它为什么不那么设计“
- 老员工忆苦思甜吹牛逼的时候多奉承几句_(:з」 ∠)_
向他人学习
有的人喜欢自己闷头捣鼓，什么也不问，这必然是不利于自己提高的；- 也有人碰到问题就问，这也有问题，浪费他人时间不说，更关键的是说明这人向他人学习的思路错了，要学习他人的并不是具体某个知识（要学知识看书就能解决了），而是学习别人的思维方式。
但是思维方式这种东西很难通过交流的方式学到，后来我发现有个很简单的学习方式：口头禅。举几个例子，大家体会一下：
“这个其实是两个问题”
“有没有更好的方案”
“能不能举个例子”
“能不能给个一句话总结”
“有没有更好的方案”
“能不能举个例子”
“能不能给个一句话总结”
除了口头禅，很多牛人都会有非常鲜明的思维方式和处事原则，如果有幸与业界的大牛共事，那么恭喜你，只要多交流、多观察、多思考，那么提升速度会提升好几个数量级。
- 遇事多想为什么，并且要反复问为什么。很多貌似理解了的问题过一阵再重新想想，往往会发现之前还有没考虑到的地方
- 问题要有明确答案，哲学之类的就别纠结了
- 查找资料时选权威的书籍或者网站，避免被误导
- 找人讨论，或者直接拉小伙伴入伙，既可以互相交流，又可以互相监督
- 分享你的成果
- 不要所有事情全都深究，会给自己太多压力
4.2.多说，多写，多交流
平常工作中有一个感受，有交流和写作习惯的人思路会更清晰一些，能接触到的观点也会多一些。这方面其实属于我的弱项，大概总结几个观点。
- 隔一段时间最好能书面形式总结一下最近的工作，比如说写个心得感悟，或者持续更新自己的简历
- 写作的时候有两个难点：对要说明的事情做总结和抽象，形成观点统一、调理清晰的主线；从对方的视角考虑，把事情说明白，避免自言自语。
- 找人讨论之前自己先要有个基本完整的思路，否则大部分的时间都要耗在解释原理之类的上网查反而更快的事情上。
- 讨论之后要有一句话就能说明白的结论和描述清晰的时间点。
- 有些人喜欢纠结于“这个不是我的问题，为什么要我处理”之类的事情。在我看来这是很好的机会。既能增长见识，又能展示水平，还能留个认真负责的好名声，何乐而不为呢。
负责任，重名声。
负责任，说的更具体些：写的代码自己有没有测过、做的框架自己有没有用过、设计的架构自己有没有认真权衡过。
重名声，说的直接些：没有测过的代码、没有用过的框架、没有权衡过的方案有没有脸交付给别人。
现在开始，使用笔记软件分门别类地保存网上看到的文章，这里要着重强调一下分类的重要性，好的分类可以节省你以后重新检索文章的时间，不要把时间浪费在不必要的劳动上。笔记软件一般都会提供浏览器插件，保存起来是很方便的。
个人 wiki 主要是用来记录知识碎片的，例如说：某个常用命令的语法，特定的软件配置等等。如果还是不理解，可以看看我的个人 Wiki。这些知识碎片是我们初步消化的知识，只不过因为太过碎片，不能够组成完整的知识体系。很多人以为把看到的文章保存到自己的笔记里面，就有一种已经掌握它的错觉，结果保存了成千上百的文章，却一篇都没认真看完。别人的文章是他的知识沉淀，并不是自己的。随时把文章中的精华提取整理到 wiki，才能初步消化知识，为后面的思考加工做准备。
- 笔记软件保存的主要是知识原料。我们从网上保存别人的文章到笔记，存下来的知识是别人的，你只是存下来而已，还没经过消化。我们上面把笔记软件定义为知识的仓库，如果把初步消化后的知识也存在那里，会造成一定的混乱。当然你一定要这么做也可以，但我有分层的思维定势，这算是职业病吧。
- 定期写文章。 万事开头难，动笔开始写作很难，一旦开始就停不下来了。养成定期写文章的习惯，至少确保一个月一篇的节奏。
- 自荐文章到各个技术头条。例如说：伯乐头条，开发者头条，极客头条等，有读者才有动力，同时也是保证自己写好文章的监督。
- 知识积累：使用笔记软件保存好的文章，积累知识。
- 碎片整理：在个人 wiki 上记录初步消化的知识碎片。
- 思考加工：对存在笔记和 wiki 中知识进行思考加工后写在博客。
http://blog.csdn.net/huangjijie123456/article/details/50570863
1 每个程序员的会出现认知失调的现象。应该正常对待。
2 再牛逼的人都会有自己的认知盲区，需要别人去发现。
3 理性对待别人发现的错误。
http://blog.csdn.net/fanqingtulv/article/details/50575605
七、建立人际关系网。这个人际关系网包括你的朋友、亲人，最低限度包括所有可以互相帮助的人。这些人有的是你的同事，有的受过你的恩惠，有的你倾听过他们的问题，有的你和他有着相同的爱好。人际关系网不是一朝一夕就能建立起来的，它需要几年甚至十几年的培养。一个人在事业上、生活上的成功其实如同一个政党的成功，你要有许多人散布在适当的地方，你可以依赖他们，他们也可以依赖你。
八、学会授权他人。许多人不肯或不能这样做，因此始终被钉在从属的职位上。授权他人是成功的一半，一个事无巨细，不能将工作授权别人的人，注定会遇到极大的障碍。你最好已成为这方面的专家。换言之，你懂得挑选合适的人并信任他们。
https://codingstyle.cn/topics/90
1 每个程序员的会出现认知失调的现象。应该正常对待。
2 再牛逼的人都会有自己的认知盲区，需要别人去发现。
3 理性对待别人发现的错误。
http://blog.csdn.net/fanqingtulv/article/details/50575605
七、建立人际关系网。这个人际关系网包括你的朋友、亲人，最低限度包括所有可以互相帮助的人。这些人有的是你的同事，有的受过你的恩惠，有的你倾听过他们的问题，有的你和他有着相同的爱好。人际关系网不是一朝一夕就能建立起来的，它需要几年甚至十几年的培养。一个人在事业上、生活上的成功其实如同一个政党的成功，你要有许多人散布在适当的地方，你可以依赖他们，他们也可以依赖你。
八、学会授权他人。许多人不肯或不能这样做，因此始终被钉在从属的职位上。授权他人是成功的一半，一个事无巨细，不能将工作授权别人的人，注定会遇到极大的障碍。你最好已成为这方面的专家。换言之，你懂得挑选合适的人并信任他们。
https://codingstyle.cn/topics/90
- 关掉不用的窗口：保持专注
- 客户端驱动（意图式编程）：先使用，后实现
- 使用快捷键
- 尽量少写：写的越少，错的越少
- 频繁提交：保证工作区是干净的，脑子的负担会小很多
- 专业 Profession
- 展现 Presentation
- 连接 Connection
像程序员这样的专业技术人员，都倾向于在专业维度不断发展提升，而往往忽略了另外两个维度。如果三个维度综合发展的话，可能会得到
1 + 1 + 1 >> 3 的效果，即三个维度相加，远远大于 3。专业行为
专业行为，包括规范化的工作流程和作风，严格的职业纪律和操守。
这些专业的行为，最终会内化成一个人的习惯，敏捷专家 Kent Beck 说过一句话：“我不是个优秀的程序员，我只是一个有着优秀习惯的普通程序员。”。所谓 “优秀习惯”，就是专业化行为的一个重要体现。
专业能力加上专业行为，会让你从周围的合作者那里得到一个做事很专业的评价。
专业产出
专业产出，指最终产出的结果是稳定的，可预测的，在一定品质标准差范围内的。
展现 Presentation
展现建立于专业的基础之上，展现也对应着专业的三个子维度。
- 展现专业能力：代码、架构、认知、决策
- 展现专业行为：沟通、交流、表达、协作
- 展现专业产出：作品、价值、发现、挖掘、洞察、演示
对应这些展现的需求，有不同的展现形式，无外乎下面这些：
- 代码：Github 等开源站提供了最直接的围绕专业能力中编程能力的所有展现形式、证据和历史
- 交流：在日常的即时通信、邮件、会议、交谈与协作中，展现了关于专业行为的一切
- 演讲：有关专业产出的重要形式，如：汇报（绩效产出）、报告分享（作品与影响力产出）
- 写作：长尾影响力的产出形式
https://mp.weixin.qq.com/s/heFyKmlmhYz2dzCgPzRUiw
把复杂的事情做简单，用最小最简单的理念把最大最复杂的世界规整起来，关注问题的本质，高效持续的解决问题。
http://blog.csdn.net/xiedongsheng/article/details/78715744
请不要对非技术人员说“这个需求技术上无法实现”
很多时候，需求的真正限制，只取决于时间或者资源。
何况，需求并没有限制我们使用某一种技术去实现。
正确的做法，绝不是急于否定需求。而是站在全局的角度：
还是一句老话，无论是技术还是非技术人员，解决沟通问题的关键，在于看待问题的方式。
http://www.10tiao.com/html/265/201802/2650463248/1.html
https://www.jianshu.com/p/67d86b5ccda4
https://bravenewgeek.com/you-are-not-paid-to-write-code/
We’re not paid to write code, we’re paid to add value (or reduce cost) to the business. Yet I often see people measuring their worth in code, in systems, in tools—all of the output that’s easy to measure.
Be coachable means that, if you REALLY WANT IT, shut the fuck up. Take everything you are “automatically certain” of, in your mind, put it in a box and stash it in a corner. It is only when your mind is empty of all notions, all fears and insecurities, that you are ready to learn.
https://blog.thankbabe.com/2018/02/22/dh-cxy/
http://www.10tiao.com/html/142/201802/2650859580/1.html
https://mp.weixin.qq.com/s/URvpwQE2sK_UDrfHtvWC8A
“发现的真正旅程不在于发现一块新的土地，而在于从新的角度，用新的观点去看问题。”——普鲁斯特（法国重要作家，他也是意识流写作的代表人物，他的代表作是《追忆逝水年华》。）
“我不认为教育仅限于学校教育。（修改：我从不让学校教育影响我的学习）”——马克·吐温
“我认为一个人今天总是要比昨天变的更明智。”（修改：智慧日进者方值得尊敬。）——亚伯拉罕·林肯
2．列个“需学习”的单子
我们都应该写个计划单子。上面列的事情都是我们应该努力去实现的目标。要试着制定一 份属于自己的“需学习”的单子。在上面你可以写上你对学习一门新知识学习的计划。或许你打算学习一门新的语言，掌握新技巧或者是阅读莎士比亚的著作集。无 论你打算做什么，都将你要做的事情记录下来。
3．结识更多有知识的朋友
与那些有想法的人多接触。有想法的人不一定就是那些很聪明的人，而是那些打算花时间学习新技术的人。他们的习惯会影响你。若他们能和你分享他们拥有的知识，那就更好了。
4．多多思考
阿尔伯特－爱因斯坦曾经说过“一个人如果读了很多书，但是却没有通过自己的脑子将这 些书中所说的东西消化，那么他就是一个懒人。”只是很简单的学习他们的明智之处是不够的，你需要结合你自己的实际情况来对你所阅读的东西进行消化。花些时 间对你所读的书写一些读后日志，思考，消化。
5．付诸实际
如果不运用那么学习就没有任何意义了。你阅读一本C++ 的书和你编写程序并非一样，学习画画和你拿画笔做画也是不一样的，如果你可以运用你所学的知识，你就要运用。
6．教导别人
将所学到的知识教授给别人。如果你能将学习到的东西用来教导别人，那么你就可以巩固你所学到的东西。创建一个博客，当别人的导师亦或和朋友讨论一些观点。
7．整理你所学到的知识
有些知识是很容易消化的，但是我们常常不能抓住其本质内容。我非常重视对我的博客中 的读者反馈进行整理。好的博客是新思路的重要源泉。但是，每隔几个月，我都会发现，我从博客里面收集出来的评论只需浏览即可。每隔几个月，对你所学习的东 西进行整理，这样就可以节省你的时间将注意力集中在那些对你有益的东西上。
我失败的最大两个关键点，希望刚步入工作的你别走我的路子：
1、只想着技术成长，不关心业务、行业的随意跳槽，最后变得缺乏行业的背景和沉淀，而没有竞争力。顶多就是个熟练写代码的码农。
2、工作中没有多思考一些，想远一些，老大安排啥干啥，最终弄得自己只能是底层执行者，难以升迁。
最后，再分享我忘了从哪看到的一个观点。他说成功其实很简单，就是：找一个好的XXX，然后坚持XXX下去。如
1、只想着技术成长，不关心业务、行业的随意跳槽，最后变得缺乏行业的背景和沉淀，而没有竞争力。顶多就是个熟练写代码的码农。
2、工作中没有多思考一些，想远一些，老大安排啥干啥，最终弄得自己只能是底层执行者，难以升迁。
最后，再分享我忘了从哪看到的一个观点。他说成功其实很简单，就是：找一个好的XXX，然后坚持XXX下去。如
找个好的公司，然后坚持努力下去。
找一个好的股票，然后坚持持有下去
找一个好的媳妇，然后坚持一起走下去。https://bravenewgeek.com/you-are-not-paid-to-write-code/
engineers should understand that they are not defined by their tools but rather the problems they solve and ultimately the value they add. But it’s important to spell out that this goes beyond things like commits, PRs, and other vanity metrics. We should embrace the principles of systems theory and Taco Bell Programming. New systems or more code should be the last resort, not the first step. Further, we should embody what it really means to be an engineer rather than measuring raw output. You are not paid to write code.
http://slash7.com/2006/12/22/vampires/- Ask your question—but phrase it differently. Instead of asking your question directly, ask “Has anyone has seen this problem?” or “Can anyone point me in the right direction?” Likely as not, someone will have been there before, and they might know a blog posting or other resource which can help you out. This way, you show you are respectful of their time, and understand your problem is (probably) not unique.
Be coachable means that, if you REALLY WANT IT, shut the fuck up. Take everything you are “automatically certain” of, in your mind, put it in a box and stash it in a corner. It is only when your mind is empty of all notions, all fears and insecurities, that you are ready to learn.
https://bravenewgeek.com/pain-driven-development-why-greedy-algorithms-are-bad-for-engineering-orgs/
If someone doesn’t feel pain, they have a harder time developing a sense of empathy. For instance, the goal of any good operations team is to effectively put itself out of a job by empowering developers to self-service through tooling and automation.
As long as you’re cognizant of this and know that at some point you will have to feel some pain, it can be okay. But if you’re just displacing pain thinking it’s actually disappearing, you’ll be in for a rude awakening. Remember, it’s a zero-sum game
Understanding the why behind something rather than just the how is critical to building empathy. It’s being able to look at a problem through someone else’s perspective and applying that to your own work. Changing your perspective is a powerful way to deepen your relationships. Pain-driven development is intoxicating because it allows us to move fast. It’s a greedy algorithm, but it provides a poor global approximation for large engineering organizations. Thinking holistically is important.
It’s time for some game theory: pain is a zero-sum game. By always following the path of least resistance, we end up displacing pain instead of feeling it. This is literally just instinct. In other words, by making locally optimal choices, we run the risk of losing out on a globally optimal solution. Sometimes this is an explicit business decision, but many times it’s not.
https://blog.thankbabe.com/2018/02/22/dh-cxy/
http://www.10tiao.com/html/142/201802/2650859580/1.html
https://mp.weixin.qq.com/s/URvpwQE2sK_UDrfHtvWC8A
缺乏验证条件时，开发的功能不经测试直接交付给测试人员。一种是过于自信的表现，还有一种是懒惰的表现。有自信是好的，但如果能经过实际的场景来检验，双重保险，对自己对团队都是保证。懒惰就是不负责任的表现，有些功能确实测试起来很复杂，但为了保证功能的可用性，没有条件去创造条件也要完成，这也是一种态度。
修复某BUG时，夹带其它问题。一个未被测试人员发现的BUG，自我发现后私自修复，并提交源码。这在测试阶段比较常见，但后期如果还出现这种问题，对产品/项目的稳定性是个极大的隐患，特别是生产环境。这是一个流程规范问题，也是一个职业素养问题。
拿到开发任务后，直接上手写代码。缺少必要的沟通与设计，返工的机率极大。前后端数据的交互格式，功能潜在的关联点不清晰，接口调用方功能是否完备，存储结构的设计，复杂业务的流程设计等等，都需要事先沟通确定好，再动手写代码才能游刃有余，不然会走一步卡一步，进展缓慢，甚至倒退。
在逻辑混乱的地方加入新东西，而不是去重构。由于功能的新增或变更，需要在旧有的代码逻辑中添加新功能，本是一个很好的重构机会，但很多的做法时在原有的基础上填填补补，结果一片混乱。特别是在本已混乱的地方还要加入新代码逻辑，运行起来确实没有问题，但对自身代码质量的保证零意义。
- 知识积累：使用笔记软件保存好的文章，积累知识。
- 碎片整理：在个人 wiki 上记录初步消化的知识碎片。
- 思考加工：对存在笔记和 wiki 中知识进行思考加工后写在博客。
知识积累难在养成积累的习惯。以前我解决某个问题，谷歌了很久找到一篇文章解决了问题。解决之后并没有记录下来，结果下一次遇到同样问题，我又浪费了很多时间搜索解决方法。重复多次之后，我意识到这是个严重的问题。所以逐渐养成了保存各种文章的习惯。这些网上积累下来的文章，成为了我知识体系的土壤。
现在开始，使用笔记软件分门别类地保存网上看到的文章，这里要着重强调一下分类的重要性，好的分类可以节省你以后重新检索文章的时间，不要把时间浪费在不必要的劳动上
随时把文章中的精华提取整理到 wiki，才能初步消化知识，为后面的思考加工做准备。- 更有效地学习新的知识。
如果我们已经建立好一个技术知识体系，新的技术也只是在其他技术上建立起来的，有了坚实基础，学习新技术就会更有效。 - 更好地掌握知识。
使用合适的工具，正确的方法，可以更好地掌握知识，让知识凝固在脑海，而不是流走。 - 节约时间成本。
程序员经常遇到同样的问题，例如说部署开发环境的时候，如果有把解决方案记录下来，就能省去重新解决问题的时间。
编程讲的是如何解决问题。但在你开始写代码之前，你需要清楚如何解决问题。一个好的程序员应该得拥有这样的技能，他能将问题分解成子问题，直到每个子问题都可以很轻松地进行解决。不过要找到一个解决问题的方式可不是件简单的事。好的程序员能够很好的对问题进行建模，这样写出来的程序很容易能看懂，很容易实现及测试。
