• 开源镜像
  • 开源沙龙
  • 媛宝
  • 猿帅
  • 注册
  • 登录
  • 息壤开源生活方式平台
  • 加入我们

开源日报

  • 2019年1月3日:开源日报第301期

    3 1 月, 2019
    开源日报 每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,坚持阅读《开源日报》,保持每日学习的好习惯。
    今日推荐开源项目:《社交网络搜寻者 sherlock》
    今日推荐英文原文:《Are Requirements Overrated?》

    今日推荐开源项目:《社交网络搜寻者 sherlock》传送门:GitHub链接
    推荐理由:这个项目可以让你在各大社交网络上寻找……一个指定的用户。只需要给出用户名,就会搜索出在那些社交网络中是否存在该用户以及它们的主页网址,如果用于娱乐的话,你大可以想一个世界上谁也想不到的名字,然后看看有没有人真的把这个名字作为用户名。
    今日推荐英文原文:《Are Requirements Overrated?》作者:Benny Reich
    原文链接:https://medium.com/@benny.reich/are-requirements-overrated-9f57d7a985a8
    推荐理由:在现在需要敏捷开发的时代,直接写个长长的需求规范兴许是个错误的选择

    Are Requirements Overrated?

    Why I don’t write long specifications.

    From Waterfall to Agile


    In the dark ages we all worked in waterfall. We planned everything months ahead of time. We had to write very detailed requirements in advance, review them and plan accordingly. It resulted in slow reaction to changes and many obsolete requirements.

    With the move to agile and the preference of working software over comprehensive documentation (see the agile manifesto) there is less demand for such long specifications. However, I still find that many product managers write much more than necessary (and I still hear the term PRD too many times).

    I would like to explain why I think it is not just a waste of valuable time, but also why it often actually results in a lesser product.

    Your Time is Valuable


    There is no question that you need to write requirements that are clear for both developers and QA. But do you really need to write them so long?

    Are you making sure to write more about the problem and the customer need and how you want to measure success and less on the solution itself?

    Do you really need get into every error case instead of trusting the development team to handle it?

    Every minute you spend in perfecting the details of a solution for a problem you already know you need to solve, is a time you don’t spend trying to find the next one. It is a time not spent on the bigger picture, on strategy or on talking with customers.

    Spend as less as you can on writing the requirements. Write them as short as you think your peer developers and QA would need to understand them. I would even argue that if you know who is going to work on implementing them, adapt them to how well you think they specifically can work with “holes”.

    More about this in Make yourself “Redundant” and Your Role is not to Write Requirements.

    Smart Creatives


    In How Google Works Eric Schmidt and Jonathan Rosenberg termed “Smart Creatives” as employees of the information age who are focused on solving problems. Hopefully you are working with such people (if your development team is outsourced what I write below might not be relevant and you might need actually to write longer and more detailed requirements).

    For this type of developers, if you are writing too much details and closing all loop holes, you are actually depriving them of their creativity. Developers want to think. They don’t want just to get orders and implement them. By writing too much details, you are actually getting less motivated developers (and don’t have me start talking about the fact that most of them are anyway not reading what you write).

    And you are losing something else. You are losing more perspectives on the same problem and maybe some innovative ideas that you did not think of. This is true also for working with UX experts. Leave them enough space to maneuver and express their creativity and thinking.

    You may argue that this can be done in the discovery phase, in which you can involve everybody, and then write the findings. The truth is that while you should definitely involve developers in the discovery phase and get their input, they would usually not be engaged as well as when they actually work on the problem. Leave some loose ends. They will surprise you.

    Escalation of Commitments


    Another issue with investing too much in the definition phase is that you may get too attached to the solution. It makes it harder to give up on things when you find that it is the wrong solution or that the scope you had in mind is too big and you need to do some cuts (see also Always think MVP).

    This behavior is called escalation of commitment. It is a human behavior pattern in which an individual or group facing increasingly negative outcomes from some decision, action, or investment nevertheless continues the same behavior rather than alter course.

    Summary


    Writing specifications and requirements should be a minimal task. You should write as less as you can on the solution and as much as you can on the problem. Keep only the things that you need in order to make sure the solution is answering the need and do not have contradictions. Do not write the details that you think your development team can understand by themselves and may even find better outcomes.

    Everybody wins. You get more time for strategy or just to work less hard and the development team gets more motivated and invested in solving the problem and coming with new ideas.
    Less is better than more
    下载开源日报APP:https://opensourcedaily.org/2579/
    加入我们:https://opensourcedaily.org/about/join/
    关注我们:https://opensourcedaily.org/about/love/
  • 2019年1月2日:开源日报第300期

    2 1 月, 2019
    开源日报 每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,坚持阅读《开源日报》,保持每日学习的好习惯。
    今日推荐开源项目:《新增了三百多个表情 EmojiPackage》
    今日推荐英文原文:《Software Quality Gifts》

    今日推荐开源项目:《新增了三百多个表情 EmojiPackage》传送门:GitHub链接
    推荐理由:今天的日报介绍的项目兴许有点奇怪,GitHub 上什么都有.jpg。这个项目是一个关于各种表情包的收录,包括但不限于各种红包,新人,程序员等等。面对接下来要到来的春节,你准备好要如何在斗图中赢过你的同学同事们了吗?这个项目可以让你摆脱巧妇难为无米之炊的烦恼,你总能在里面找到些合适的表情回击他们。
    今日推荐英文原文:《Software Quality Gifts》作者:Julie Griech
    原文链接:https://medium.com/@juliee216/software-quality-gifts-2fecce17e277
    推荐理由:作为软件测试人员,你会从周围得到些什么来帮助你进行测试

    Software Quality Gifts

    gift – noun Definition:
    • something voluntarily transferred by one person to another without compensation
    • something bestowed or acquired without any particular effort by the recipient


    I frequently find myself surprised by happenings in the world of software development. New technologies find their way out of the limelight and become old technologies. Old technologies somehow become the latest and greatest thing again. We find a new way to implement our processes in order to make them more useful. We learn better ways to manage teams, or be part of a team.

    My most recent surprise came in the form of what we, as software testers, receive from the world around us for free that helps us do our job better. The things we receive intentionally and formally (not for free) are requirements, feature branches for early testing, test files, wireframes, and prototypes…to name only a few. We have so many formal ways of obtaining information on a feature or a change, but the informal ways are where we learn the unexpected.

    What has been gifted upon us that has a valuable impact on our testing process?

    The first gift is bugs. Software bugs are clearly undesirable, but also they are inevitable. We never want to see a bug, but given that they will occur, let’s make something of them.

    The most obvious benefit that we can take from a bug is that is demonstrates something we missed in our testing and planning. We can take this missed validation and ensure we have future test coverage for it, but also to determine if there is a commonality in other tests where this type of bug could occur. We can now not only inject that information into our testing and planning, but also into our requirements discussions and development implementations.

    Bugs can also uncover if something was designed differently than how it was expected to be used. An intentional design or implementation decision can be interpreted by a user as a bug if it prevents them from doing something a certain way, or at all. These bug reports are extremely useful in helping testers do more exploratory testing in order to branch out in our expectations of how something should behave.

    Bugs spark interest in a tester and help us think outside of what we already know.

    The second gift is seeing others use the product.

    We can become quite habitual in how we use a familiar software tool. I myself am a “keyboard person.” Give me all of those keyboard shortcuts! Even when I branch out to using the mouse, I still find myself using muscle memory for each action I take in our software. We have testers who we know are more keyboard focused or more mouse focused, and we capitalize on that for test coverage.

    However, these are the things that we know. And if we have our habits, then our users certainly do too…only we don’t know what those habits are.

    How a user gets to end of what they are trying to achieve in our software is infinite. Users could be methodical and direct, or very scattered. They could be very heavily focused on one feature or area of the product. They may have their screen configured in a totally unique way. All of these different elements of use are great inputs into use cases, usability, and general testing.

    Most of these things are not and cannot be documented because they are nuanced and may be combined differently from one time to the next. The key is to see these actions as they happen, and to watch the user and see this uniqueness in real-time.

    There are infinite takeaways from watching how users physically interact with our software, and these takeaways have a clear and positive impact on our testing, planning, and automation.
    The third and final gift is experts.

    We have at our disposal an array of product experts in our Designers, Product Managers, and Developers. These internal experts are the people who are the most closely involved in our products, with our users, and in our market. These are the individuals who can answer our questions and can go further in-depth about how something is intended to be used or not used. These are the people we can discuss and debate UX with, who can help us develop more effective test cases, and who can explain the minutia of each feature and its functionality. These are also our most trusted team mates who want to ensure that our test coverage is as effective as it should be.

    Product Managers and Designers are the closest individuals to our users. They have the most experience with what the market wants, and they add so much more to the creative process than simply requirements and prototypes. There is no substitute for real-world feedback because we are creating our products for the real world. We should be taking full advantage of their knowledge and expertise by integrating them into test plan reviews and by enabling a clear and open feedback loop on our testing.

    Developers deal with features and functionality at the micro level. Every day they dig deep into features and their implementation, and can provide technical direction for how we test and automate along the way. Developers want their work to be bug free and thoroughly tested, so their input is well-intended and highly useful. Here as with Product Managers and Designers, the feedback loop should be clear, open, and transparent.
    We have so many intentional inputs into software development such as requirements, user stories, and designs. These inputs are common to virtually every development organization. We will extend our means to effectively test and plan by taking in and utilizing the unexpected and free gifts that we have available to us on a regular basis.

    The beauty of these gifts is that each one can spark new ideas which in turn can lead to more effective exploratory testing and better test coverage. All of this will help us create better software with excellent quality, and better experiences for our users.
    下载开源日报APP:https://opensourcedaily.org/2579/
    加入我们:https://opensourcedaily.org/about/join/
    关注我们:https://opensourcedaily.org/about/love/
  • 2019年1月1日:开源日报第299期

    1 1 月, 2019
    开源日报 每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,坚持阅读《开源日报》,保持每日学习的好习惯。
    今日推荐开源项目:《简单方便实惠 notable》
    今日推荐英文原文:《The Art of a Well Composed Pull Request》

    今日推荐开源项目:《简单方便实惠 notable》传送门:GitHub链接
    推荐理由:这世界上没有一个具有如下特点的 Markdown app: GitHub 风格,没有 WYSIWYG(尽管这在某些时候很方便),没有专用格式,支持附件,允许导入等等。所以我就自己造了一个。——作者
    如果没有就自己做一个适合自己的 app,这个思想是相当好的,自己动手不仅能满足需求还能学到东西何乐而不为呢?
    今日推荐英文原文:《The Art of a Well Composed Pull Request》作者:Zoe Larsen
    原文链接:https://medium.com/@zlarsen.zl/the-art-of-a-well-composed-pull-request-3815fc7e9610
    推荐理由:Pull Request 的艺术

    The Art of a Well Composed Pull Request


    What is a Pull Request?


    A pull request (PR) is a request submitted to a GitHub repository to merge code into that project. The PR allows requested reviewers to view and discuss the proposed code. Once the PR passes all standards of reviews and all necessary revisions have been made, it can be merged into the code base.

    To get an in depth overview of git and how to make commits, PRs, and repositories; here is a great guide to get you started: git — the simple guide

    The purpose of this article is to present good practices for how to piece together a PR that is clear, easy to review, and inherently self-documenting.

    Why are Pull Requests Important?


    Pull requests are important because they help ensure that quality reviewed code is merged into GitHub repositories. Without PRs, messy and confusing code can easily run rampant in a code base. Each developers’ style of programming will compound into a repository with wildly different standards of code. This creates a confusing repository that is difficult to decipher for new developers or even the same developers six month later. PRs are a gate keeping tool to prevent bad or malicious code from being merged into the code base.

    Even with this tool, it does not prevent developers from making bad PRs. Especially if there are time restraints, a complex set of commits, or a myriad of other excuses, it’s easy to lump all code changes into a single commit and push it up the repository. However, that is a terrible PR for other developers to review. A bad PR with sparse description and no forethought for how it’s structured can waste multiple developers time.

    Concise pull requests allow for developers to efficiently review and quickly merge code into master. Mastering the art of a well composed PR will make you a valuable asset to any developer team.

    Pull Requests are Made of Commits


    A pull requests is made of a number of committed code changes. The developer then pushes the commits to a repository on github. It’s important to organize commits in a coherent manner to best convey what changes were made to the code made with each commit.

    I personally try to organize my commits with some sort of flow in mind. I think it’s important to have some sort of story that helps make the abstraction of coding into something that easier to read through and understand. Here are several ways to organize commits

    + MCV flow: commit changes made to the model first, then followed by changes made to the controllers, finally changes made to the views. + Importance flow: Commit changes that are the most important first then commit associated minor changes. + Biggest to smallest flow: Commit changes that were the biggest changes to the code, followed by more minor changes.
    These are just a few suggestions, there may be better ways to organize your commits that make the most sense to your team. The most important takeaway is to put some thought into it.

    Thus when the commits are pushed to the GitHub repository and the pull request is made, it is easy for a PR reviewer to go through each commit and understand the thought process that necessitated the changes made in each commit.

    I try to keep commit messages as concise as possible and limit the code changes to a single idea or step.

    A useful git function for organizing commits is rewriting commit history.

    Commit Tips


    I structure my commit messages the following way

    + Title summing up the code changes I made in the present tense. + Message of why I made those changes.
    Change variable name foo_bar to foo_bars
    
    Renamed the variable foo_bar to foo_bars across all files that had that variable. Renaming this variable better conveyed that the variable was an array of strings instead of a single value.
    

    I avoid commits that have a ton of changes across many different files unless they are all a similar change.

    For example, If I made changes to a user controller file, a product subscription helper file, and product view file I would make three commits for the changes I made in each file.

    Another example, if I made changes to ten view files that just changed the same variable name to a new variable then I would add all ten files to one commit.

    Finally before you push up all your commits and are ready to open a new pull request, do everyone a favor and personally review your code.

    Make sure you try to catch as many dumb small mistakes as you can.

    Indention off? Fix it.

    Variable/function names not very clear? Rename them.

    DRY up your code.

    You will save yourself and your reviewers time if you catch these hiccups before submitting them for review. Nothing sucks more when the senior developer comments that you misspelled organism_name as orgasm_name.

    Usually I’ll commit these small changes and fixes as a personal PR review.

    A Well Composed PR


    Now that we have some well structure commits we can now push our changes to the GitHub repository and open a brand new PR. Composing a PR is similar to composing a commit, except it encompasses the whole purpose of the code changes instead of the small changes made to each file or feature.

    PR Title


    I sum up the general purpose of the PR being made in the title as concisely as I can manage. I typically have the general goal of the PR followed by the area and function

    For Example:

    + New Design Bug Fix: User Controller Index Action. + System Test: React Tables Basic Functionality. + Model Bug Fix: Permission Class Method Update.

    PR Body


    For the PR Body Message I break it up into several sections.

    + Purpose of PR/What Issue it is Resolving + Main Changes made + Code Before Changes/Code After Changes + Additional media resources (Images, links to other PRs/Issues)
    I also include other media sources if they are relevant to help explain the changes made. Things like before/after images for view changes, gifs to show functionality changes, or other media assets would be great to help illustrate what happened in the PR that affected the code base.

    Additionally, I link any issues or other PR’s that are associated with the current PR being reviewed. This is especially helpful for the future when, for whatever reason, you or another developer have to look back on the changes you made.

    You might have to figure out why such vague variable names were assigned, why such hacky code was implemented, or a myriad of other things that make sense now but won’t in a few months when you have completely forgotten about this pull request.

    Having as much contextual information associated with the PR is extremely helpful for future developers.

    The PR Conversation


    Finally once you have crafted a fine PR and submitted it for review, the work is not over yet. The developers reviewing your PR will no doubt make comments on your code to clarify something or ask you to make revisions. This will start the conversation in your PR review.

    I find that it is important to respond to every comment made on your PR with either a thumbs up emoji to acknowledge that you made small changes requested and with another comment if you need to explain something. Including images in your comment response when necessary is also a great way to help clarify your response.
    下载开源日报APP:https://opensourcedaily.org/2579/
    加入我们:https://opensourcedaily.org/about/join/
    关注我们:https://opensourcedaily.org/about/love/
  • 2018年12月31日:开源日报第298期

    31 12 月, 2018
    开源日报 每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,坚持阅读《开源日报》,保持每日学习的好习惯。
    今日推荐开源项目:《过去与未来同样闪耀 HistoryOfEverything》
    今日推荐英文原文:《The History of Everything》

    今日推荐开源项目:《过去与未来同样闪耀 HistoryOfEverything》传送门:GitHub链接
    推荐理由:在今年的最后一天,让我们来看看过去的历史吧。这个项目是一个关于时间线的 app——比如宇宙和地球的时间线。在不知不觉之间这个世界已经存在了非常长的时间,我们也是一样的,但是无论过去是耀眼的还是平淡无奇的,下一秒的未来也无法确定,在确定之前都不要放弃对闪耀未来的希望才是最重要的。
    今日推荐英文原文:《The History of Everything》作者:Guido Rosso
    原文链接:https://medium.com/2dimensions/the-history-of-everything-981d989e1b45
    推荐理由:HistoryOfEverything 的介绍文章

    The History of Everything

    Over the last three months, we’ve been working with Google to create an app that showcases the raw horsepower that Flutter has at its disposal. We wanted to create a real-world app that wasn’t just a demo. It needed to demonstrate not only how powerful Flutter apps are, but also how they enable developers and designers to create completely custom experiences on top of native design mechanisms. For us at 2Dimensions, it was also a unique opportunity to show off some compelling graphics built with our brand new design tool, Flare.

    The app we designed and developed is the History of Everything, which uses some fancy scrolling mechanisms to allow the user to scroll and zoom the timeline, dynamically showing/hiding animated historic events as the available space allows. We use Flutter’s ScrollPhysics and GestureDetector to make scrolling feel native on both iOS and Android. This is built into a custom widget, where we’ve added additional view and zoom abilities. This allows the user to navigate through the timeline in a way that feels totally natural on their device, yet also adds elements of playfulness that are unique to this experience. This is what we love about working with Flutter, and all of this is done with a single codebase.

    The inspiration for this concept came from The History and Future of Everything YouTube video, one of our favorites from the Kurzgesagt channel. If you’re not familiar with Kurzgesagt, they make beautiful videos with stunning animations, using concepts that tie together science, history, and art. This quote from Kurzgesagt sums it up well:

    We create beautiful videos to share our passion for knowledge. We value quality over quantity, always. Nothing in the universe is boring if you tell a good story.

    The app has been available since December 4 in the iOS App Store and on Google Play.

    Today we are releasing the source code on GitHub! Feel free to take it for a spin and poke around, and please let us know if you have any questions or comments. All the animations are available as public files on our site. We hope this will serve as a great example for both the Flutter and the Flare communities!
    下载开源日报APP:https://opensourcedaily.org/2579/
    加入我们:https://opensourcedaily.org/about/join/
    关注我们:https://opensourcedaily.org/about/love/
←上一页
1 … 184 185 186 187 188 … 262
下一页→

Proudly powered by WordPress