开源日报 - Page 113 of 262

开源日报第591期：《不登录 awesome-no-login-web-apps》

27 10 月, 2019

开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《不登录 awesome-no-login-web-apps》
今日推荐英文原文：《On the Joys of Programming》

今日推荐开源项目：《不登录 awesome-no-login-web-apps》传送门：GitHub链接
推荐理由：说到保存用户信息，第一个想到的估计就是注册登录系统了——所以我们拥有非常多的帐号，以至于不得不找个小本本记下他们。这个项目收集了不需要登录的 web 应用，当然这并不是说它们都不存储用户数据，只是换了个方法存储而不是让用户为每一个应用记下一个单独的帐号密码来简化用户的使用流程（众所周知在所有地方使用同一个帐号密码是极其危险的）
今日推荐英文原文：《On the Joys of Programming》作者：Matthew MacDonald
原文链接：https://medium.com/young-coder/what-makes-programming-fun-9c5ab05a5440
推荐理由：作者分享的自己从编程中获得的乐趣
On the Joys of Programming

Coding is part career, part passion. Here’s what makes it worthwhile.
The dream of becoming a programmer is alive and well. College computer science courses are struggling to meet the demand. Coding bootcamps, stuffed full of would-be career changers, are surging in popularity. Even grade school educators are teaching coding as a sort of 21ˢᵗ century literacy.

For some, the motivation is simple. It’s the dream of being paid well and getting to call the shots (maybe even wearing flip-flops to the office). That can definitely happen, and it’s no small detail. After all, any work is more rewarding when you’re respected for your skills and rewarded for your efforts.

#CoderLife

But like so many pursuits that require single-minded, self-motivated work, programming is only worthwhile if you have a spark of passion for the craft. On some level, you need to like coding — to have the drudgery interrupted by moments of satisfaction and even joy. And that also happens.

In this article I’ll share what motivated my coding sessions back in the day when I typed many more semicolons than I do now, and why the blinking cursor still calls to me from my white-on-black Material-themed VS Code window.
1. Solving the puzzle
When people used to ask me what programming was all about, I’d say something like this: “Puzzles are fun, right? What if you could solve puzzles all day long?”

For me, programming starts at the puzzle. Every code routine is an invitation to face down a mental challenge. Except this challenge isn’t a mere diversion like a Sudoku puzzle, but a real-life riddle with real-life consequences. And these puzzles are all around us. They can be challenging, like calculating real-life movement for imaginary objects. Or they can be simple, like writing the most efficient code to send periodic WhatsApp notifications to your parents. The puzzles are infinite. You will quite literally never run out of them.

Here’s another interesting thing about every programming puzzle: it doesn’t have just one answer. It’s a puzzle that you’re almost guaranteed to get right but not perfect. It’s a puzzle you can return to a week, a month, a year later, and keep polishing it into a better state. (If you like to spend hours organizing your to-do list or alphabetizing your record collection, you’ll like this part.)

There’s a balance here. Solving a new problem is joy. Improving an old solution is satisfaction. And the whole cycle — solve, test, refine — is addictive.

Of course, programming isn’t all solutions. Between the challenge and the joy is a long slog of frustration, where a lifeless piece of metal points out your every tiny syntactical slip-up. But if you’re motivated by things you know you can do — even when you can’t quite figure out how you’re going to do them — programming is the perfect perpetual challenge.

Sisyphus did not invent code, but he understood the struggle
2. The satisfaction of building something
If programming was just a series of puzzles, it wouldn’t amount to much. Eventually you’d feel like you were playing endless rounds of Freecell.

But here’s the difference. Every coding project ends by interfacing with the real world. Whatever you make has a purpose — maybe it’s just a laugh, maybe it’s just an experiment, maybe it’s just for you — but all code exists to create things that will be used.

When you build something that’s genuinely useful, you get a feeling of satisfaction. You didn’t just contribute your effort. You made a tangible product! Maybe that’s similar to the pride a carpenter feels when fitting together a new piece of custom furniture. (I don’t know — I just Ikea my way through every home decor challenge.)

Programming is also more personal than most non-coders realized. As a programmer, you probably don’t think of yourself as an artist, but somewhere in every new digital creation are your fingerprints. That makes life awkward when things go wrong, but immensely gratifying when they go right. (At least until the next refactoring.)
3. The magic button click
Developers like to say that programming is about problem solving, but we also have a secret. We are happy each and every time something comes from nothing. It’s a magic trick. It’s a new toy. You click a button, and something happens. A piece of hardware has submitted to your will, reacted to your commands. Even a “Hello, World!” program is fun. The magic is in making something happen.

Most programs are — on their own — not that dazzling. But every time you put your fingers to the keyboard, you have the ability to create something using nothing but mad skillz and imagination. And that new something can entertain, amuse, or challenge others, or just plain make their life a bit easier. That’s a super power.

See what I did there?
4. There’s always something new
In many walks of life, you can make a choice. Take the easy path, try to get as comfortable as possible, and work to keep the good times rolling. Or, you can take the steeper climb, and dedicate yourself to something that you’ll need to work at — forever.

Software development is an example of the second path. To be successful, you need to be constantly learning. I remember a year that saw three different databases APIs come through the door. All three had a different set of objects and slightly different abstractions, but they served the same basic purpose for the same underlying database. In other words, these were small changes.

Constant learning keeps life from getting stagnant. And who doesn’t want to play with the latest tech toys? Coding is like that — there are always shiny new things on the horizon. New tools, new libraries, new tricks and techniques.(This week I’m playing with Blazor, an early-stage framework for building web browser applications in WebAssembly. If it succeeds — and it’s a big “if” — the entire world of client-side development will be reinvented once again.)

But the pace of change in tech can be exhausting. Few years pass without at least one small revolution. Just at the moment where you think you’ve figured out every detail of the inner workings of the latest JavaScript framework, a tech megacompany pops out a new one. If I had a dollar for every paradigm-shifting coding library that’s dropped in my lap, I could retire and code for free.

This is also the life of a programmer — always learning and often confused, peering around in the darkness, and Googling through the late-night hours.
In coding, there is often tedium, but there is rarely boredom.

Final thoughts
No discipline is straight up joy from beginning to end, and there are plenty of things about programming that aren’t fun, from sunless days in a Aeron chair to pages of code that won’t work even though they should (or, worse, work even though they shouldn’t). But those who stick with it — those who make software coding their life — know the rewards. Because what other field invites you to imagine something new — and then design it? What else gives you the chance to create every day?
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第590期：《字体展览 beautiful-web-type》

26 10 月, 2019

开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《字体展览 beautiful-web-type》
今日推荐英文原文：《How You Can Improve Your Programming Skills》

今日推荐开源项目：《字体展览 beautiful-web-type》传送门：GitHub链接
推荐理由：这个项目收集了许多开源字体并展示它们——用了一种简单直白的方式。既然要展现一种字体，最好的方法就是写出来，项目网站上每个字体都用一种风格占据了页面的一部分，并且在详细介绍页将这种字体在常用的各种用法下的效果都表现了出来，作为介绍字体的页面可以说相当吸引眼球，而且的确有许多美观的字体可以使用（尽管没有中文字体）。
今日推荐英文原文：《How You Can Improve Your Programming Skills》作者：Indrek Lasn
原文链接：https://medium.com/better-programming/how-you-can-improve-your-programming-skills-a439d47c26a4
推荐理由：坚持学习总是不会错的
How You Can Improve Your Programming Skills

Programming is a skill where you can constantly improve and learn new things
Programming is one of those crafts where you can never know everything. It’s literally impossible to know everything across all topics related to programming since there is so much information out there. If you’re struggling to stay sane knowing this, know that it’s probably best to keep your head to for new information and be comfortable with the fact that you can’t possibly know everything, albeit you can definitely improve each day. Here are four ways you can achieve that.
Code Every Day
Coding is a skill like any other. It requires a ton of practice and effort to get good at it. Not a single person woke up one day and suddenly became good at programming. All the good engineers worked countless days and nights to perfect their programming skills. Make it a habit to code each day, no matter the project or the programming language — what matters is you actually do it each day.

Photo by Lee Campbell on Unsplash

Oh, and don’t just write code. Try to read other programmers’ code, talk about code, and try to find experts to review your code. Programming is a skilled craft, and you don’t get good at a craft just by learning the rules. You get good through practice and reflection.
Learn Multiple Programming Languages
There’s a reason why universities and schools introduce multiple programming languages for their curriculums. Coding knowledge transfers over languages. For example, being familiar with Javaclass and object-oriented programming makes you more prone to understanding concepts for the Swift programming language since the same coding concepts apply to both.

Photo by Kobu Agency on Unsplash

Programming started to really click when I learned different concepts from multiple languages. I learned about structs from Swift, functional programming from JavaScript, object-oriented programming from PHP — you get the idea. Combining all the bits and pieces across multiple languages definitely helped me solidify the bigger picture and made me better at programming. Don’t get stuck in a small corner. Try to explore the unknown, and often. It’s okay to feel like you don’t know something. After all, that’s the only way we can learn, by absorbing new information.
Teach and Help Other Programmers
Have you heard about the protégé effect? It’s a fun way to learn by teaching others. The protégé effect is a phenomenon where teaching or preparing to teach information to others helps a person learn that information.

Teaching a subject means you’ve got to take on a different perspective since you’re not familiar with the depth of how much the student knows already. Therefore you have to assume the student doesn’t know much about the topic, which means you have to start teaching from the very fundamentals. The only way you can teach fundamentals is by knowing the fundamentals inside and out.

Photo by stem.T4L on Unsplash

One way of learning by teaching is plastic platypus learning or platypus learning techniques. This technique is based on evidence that shows that teaching an inanimate object improves understanding and knowledge retention of a subject. The advantage of this technique is that the learner does not need the presence of another person in order to teach the subject. Read more about the topic on Wikipedia.

Plastic platypus learning in action — https://en.wikipedia.org/wiki/Learning_by_teaching

You can start small. Pick up a GitHub issue and try to help one person every day. I like to answer one question per day on StackOverflow just to learn and help every day as much as I can.
Conclusion
Programming is fun, albeit hard to master. Ask yourself: If you really want to master programming, are you willing to put the extra effort in? You know the answer by now.

Thanks for reading, stay awesome.
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第589期：《表情扫雷 emoji-minesweeper》

25 10 月, 2019
开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《表情扫雷 emoji-minesweeper》
今日推荐英文原文：《How To Benefit From a “Failed” Technical Interview》

今日推荐开源项目：《表情扫雷 emoji-minesweeper》传送门：GitHub链接
推荐理由：扫雷应该说是家喻户晓的游戏了，小时候微机课上就靠这个来打发时间。现在这个项目将表情包和扫雷结合了起来，你可以通过自定义选择各种各样的表情来把扫雷玩出花来，表情包最起码比干巴巴的格子好看上不少了。然后择日不如撞日的打算试一下，果然当场丢人

今日推荐英文原文：《How To Benefit From a “Failed” Technical Interview》作者：Melody Habbouche
原文链接：https://medium.com/better-programming/actionable-steps-after-coding-interview-2e904c0cc3af
推荐理由：失败只不过是一种新的经验而已
How To Benefit From a “Failed” Technical Interview

What to do after an unsuccessful coding interview
Technical programming interviews are like the heartbreak of tech — nobody loves them but we all have to go through them.

They’re long, endless, and sometimes leave us walking out, thinking: “What was that?”

We’ve all been there, the long nights reviewing Cracking the Coding Interview, and solving all the problems we possibly can on HackerRank, only to arrive at an interview and be asked a question that gets us absolutely stumbled and flustered. It happens.

There’s a lot more you can do than just tell yourself you’ll do better next time. In fact, if there’s one action — well, maybe a few — that you can do after your technical interviews to benefit from this experience, here they are!
1. Go Over the Questions That Didn’t Go So Well During the Interview
So you walked out frustrated, you didn’t solve that challenge all that well and left the interviewer with a few disappointing lines of code.

Not a good experience, but the only thing you should do some time in the next few days, is taking the time to solve it on your own. You can take this unsuccessful experience and become a better problem-solver because of it.

Here’s what I like to do (similar to the approach in CTCI):
- Right after your interview, write down any details you can remember about the question.
- Go ahead and take your time to solve it. If you need resources, or you need a few Google searches, go ahead! You’re doing this to learn! Use the same approach you would in front of an interviewer (clarify, analyze, plan, implement, test).
- Once you feel like you’ve found a good enough solution, identify the time and space complexity. Then, identify some possible improvements (a few Google searches will help here too!).
- Make any improvements you can. Are you happy with your solution?
2. Identify Points of Failure (the Bad)
After you’ve come up with a new and better solution, it will make the mistakes you made during the interview more evident to you.

Write down what you think didn’t go so well:
- Did you communicate your thinking and process out loud in an efficient manner to the interviewer?
- Did you write an algorithm that worked for all given inputs? Or did you need to often re-iterate your solution for it to work for all the cases?
- Were you careful in the naming you used for variables? Was your code clean and focused, or was it messy and contained duplications?
By identifying these impediments that happened during your interview, you can tackle them and improve on them.
3. Recall Anything That the Interviewer May Have Taught You (the Good)
Now that you’ve identified the bad, use it to become better.

All the best interviewers will mentor you to better programming during the interview itself.

Let’s focus on one example to understand this approach:

Were you careful in the naming you used for variables? Was your code clean and focused, or was it messy and contained duplications?

This has happened to me before. The interviewer pointed out that my code didn’t contain meaningful names and gave me the chance to correct them! I didn’t realize how much bad naming had an impact on my understanding of the code I was writing, i.e. getting confused between different variables.

This small exercise that the interviewer made me do of giving my variables meaningful names took two minutes but might stick with me my whole life!
A bad example
Here is a block of code to get the factorial of a number, using Python, where we use random naming for variables and function names.
```
a = int(input("Enter number:"))

def fact(a):
  fact = 1
  i = 1
  while i <= a:
    fact = fact * i
    i = i + 1
  return(fact)

fact(a)
```
The reason why this is a bad example is that the lack of precision in naming might not seem so bad in a small program but as your program gets slightly more complex, it might become difficult to recognize which variables refer to what.

We might confuse “a” with “i”, we might even confuse the function name “fact” with the variable “fact” as they have the same name.

This is an example of a bad practice to show your interviewer and can even be an identifier for you to not be selected out of other candidates because it is such a basic but essential concept in programming.
A better example
We can improve our code by giving meaningful names related to our intentions. We can also avoid using the same name twice.
```
user_input = int(input("Enter number:"))

def factorial(user_input):
    result_fact = 1
    i = 1
    while i <= user_input:
        result_fact = result_fact * i
        i = i + 1
    return(result_fact)

factorial(user_input)
```
You can read more about cleaner practices in Clean Code: A Handbook of Agile Software Craftsmanship, a very detailed book that will definitely train you to become a better programmer.
4. Understand What This Process Has Taught You About the Company Itself
The interviewer says a lot about the company itself. Anytime you are going in for an interview, you are just as much interviewing them. The interviewer could be your next mentor or manager.

This can go in two directions:
- Was the interviewer grilling you with difficult questions, leading you to inevitably fail? Did the interviewer not help you or guide you in any way to get the solution? Did they not provide any feedback for improvement?
- Was the interviewer challenging you in a positive way and continued to help you when you were stuck for a long time? Did they offer positive reinforcement?
How the interviewer communicates with you, offers guidance, and shows mentorship throughout the interview has a high correlation with how they actually help others in their day-to-day work.

This is something to look for, and to help you assess the company’s processes and culture and whether you want to work for them or not.
5. Solve This Challenge With Another Language
You “failed”, you learned, you did better. Now what? Go the extra mile and solve the question in another programming language that you haven’t used in a while!
Conclusion
It’s important to learn from every experience, good or bad. These steps can become second nature to you after multiple coding interviews and you’ll be repeating the process until you’ve mastered these interviews!

At the end of the day, technical interviews are just that. Interviews. A somewhat flawed process that doesn’t work for everyone.

It also doesn’t determine your abilities or your worth as a programmer, so don’t burn yourself out. Some things are out of your control, but determination and hard work definitely play a role in getting your dream job!
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第588期：《瞎写 emojify》

24 10 月, 2019

开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《瞎写 emojify》
今日推荐英文原文：《Just Keep Coding!》

今日推荐开源项目：《瞎写 emojify》传送门：GitHub链接
推荐理由：众所周知，要实现一个效果，可以用无数种方式编写代码，当然也包括瞎写。这个项目可以转换你的代码，让它以一种充满表情包的新方式实现和原来完全一致的效果。它唯一一个实际点的用途就是对外掩盖你真实的代码了——不过你有一百种更好的方法，所以仅把这个用于娱乐比较好，向不会编码的朋友展现表情包的真实力量吧。
今日推荐英文原文：《Just Keep Coding!》作者：Roberto Hernandez
原文链接：https://medium.com/better-programming/just-keep-coding-5070618b330f
推荐理由：熟能生巧，熟练才会带来力量——这意味着在熟练前会踩很多坑
Just Keep Coding!

A letter to junior developers
Hi Junior Developer,

I decided to write this letter to you. You’re probably just starting out on your dream developer career. I was there at some point and know the feelings of fear and doubt very well.

So I thought why not write a letter to encourage and motivate you to keep coding. There’s plenty of people of the net already talking about the technical stuff. Just remember, no matter how many mistakes you make or if the apps you develop don’t have the quality of outcome as you expected, just stay focused. Stay swimming on this ocean of codes, where you’ll eventually grow your seed through the code you create to make life better and processes easier.

The aim of this is to show you in this stage that despite it being hard right now, there are some valuable and powerful things you can take advantage of. So don’t worry! Even the most seasoned developers have felt and passed the same stage, under the same struggle. And, of course, you’re not alone. Though I am still a beginner at some topics, I am learning and getting better every single day.
The Beginner Stage
Sometimes you probably feel like this stage pushes you forward, and other times it pushes you backward.

For a while, you feel the momentum and say, “This is living. This is what I want to do with my life!” But when things are hard to solve or when you face complex concepts and you’re not able to figure them out, you might say, “Come on! This is not what I want to do for the rest of my life.” You feel frustrated and need encouragement to move forward. It’s a struggle that lives inside you and is holding you back. I know this feeling very well, too.

At this stage, you make a lot of bad things, and this is given for different reasons: Some of you want to get a job fast. Others just want to survive or need to earn some money, so you’re more likely to accept low-budget projects.

So we’re making bad decisions, making optimistic plans, and building software with poor and low-quality code as well. But this is normal. It’s just the beginning. You’ll find a way to jump to the next level. I can categorically say to you: It is worthwhile — just keep coding!
The power and values of this stage
I would like to spotlight the most important values at this stage: the willpower, the voraciousness, and the ambitions you’ll need in order to learn more, to become better, to have the courage to go beyond your goals, the willingness to give the extra mile, and the ability to be humble and embrace feedback.

Take advantage of these superpowers to progress in your development skills. You and I have dreams and goals, so we must force ourselves until we accomplish them. Add value to this world with your code by helping others. We want to be part of the change by writing quality code and sharing our knowledge, experiences, and lessons. The world will thank you!
Your desire to build a successful developer career
Most of us want to build a successful developer career, right? But let’s first clarify what a successful developer career means.

Successful, in general, means you’re able to accomplish your own metrics or your goals.

For some, the goal may be adding important contributions to an open-source project. Others may want to impact and help others with their knowledge by acting as mentors. Others want to leave footprints with their code. And some just want to work in a fantastic tech startup or at a big tech company, such as Google, Facebook, LinkedIn, etc. The list is endless.

But in general terms, it all comes down to becoming a strong developer — a master on what you do — then deciding how to get your ideas into the world.
Self-motivation, self-discipline, and focus
I truly believe building a solid developer career is not easy, and you won’t accomplish it overnight.

If someone else has told you the opposite, he/she has lied to you. Having said that, building a strong developer career depends on several factors, and all of them play on your side so you have control over them.

From my point of view, the three most important factors are self-motivation, self-discipline, and focus. Without focus, you don’t clearly know where you want to arrive in the short, medium, or long-term. Your sight is a blur — you might not have a clear path or you might even have the wrong path.

The real problem when we start out in this career is that we are expecting to see great results after we finish some video courses, some tutorials, some posts, or after completing some pet projects.

But the software-development field works the same as when you start to go to the gym. If you want to see progress, you should build self-discipline and self-motivation. You’ll see notable results after some weeks and months — as long as you maintain your consistency and discipline. You must train your brain and develop the muscle to gain use cases, becoming better at problem-solving and more creative.
Finally, Some Advice
Finally, I would like to give you a few tips and a piece of advice based on my learned lessons, experiences, mistakes, and failures.
Enjoy the process
I know this stage is hard in terms of how to get, retain, and understand all the information, concepts, paradigms, design patterns, data structures, and algorithms you’re receiving every day.

I encourage you to just keep coding. Enjoy what you’re working on no matter if it’s a small, medium, or big project. Please stop focusing on the results — enjoy and travel with the process instead. The results will come in time.
Plan first — then code
In the beginning, I constantly skipped the planning phase. I just wanted to see real progress and outputs on my UI. I started the task just thinking a little bit about it, without doing proper analysis and planning the best way or approach to solve and complete it. I ended up wasting more time in the end.

Plan and objective, and stay aware of it. But then code. Too much planning it also not a good idea.

To solve a problem, think about the different ways to solve it.

Usually, when we’re in front of a problem, we try to solve it as soon as we can. We decide to go with the first solution that comes to us. We forget to think of the complexity, the use cases, and the buggy potentials.

Just keep coding — it’s the only way to master this field.

Thanks for reading!
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/