开源日报 - Page 157 of 262

开源日报第416期：《此霓虹非彼霓虹 synthwave-vscode》

5 5 月, 2019

开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《此霓虹非彼霓虹 synthwave-vscode》
今日推荐英文原文：《AI Will Never Be Able to Replace Teachers》

今日推荐开源项目：《此霓虹非彼霓虹 synthwave-vscode》传送门：GitHub链接
推荐理由：一个 VSCode 主题，为你的代码加上霓虹灯的特效。项目灵感来源于以前的艺术，而实现发光的方法也是相当基础的纯 CSS。唯一的小小缺点就是需要在 VSCode 更新后手动重装发光代码了，如果你也想借此机会制作自己的主题的话，可以参考一下这个网页。
创造主题：https://css-tricks.com/creating-a-vs-code-theme/
今日推荐英文原文：《AI Will Never Be Able to Replace Teachers》作者：Il Kadyrov
原文链接：https://towardsdatascience.com/ai-will-never-be-able-to-replace-teachers-394b4458394f
推荐理由：AI 会帮上老师的大忙，但是肯定没办法替代他们
AI Will Never Be Able to Replace Teachers
Having written several articles about Artificial Intelligence and about the future of robots in our life, I decided to write another article, but now my opinion suddenly changed, now I believe that these robots will not be able to completely replace us in this matter — teaching. Probably one of the hardest works in this world, not in terms of physical, but in terms of emotional and spiritual. And then the robots have not so many chances to get close to us in terms of the qualities that a teacher should have. But they will definitely be able to help teachers and make the process of teaching children easier and easier for them, will be able to make this process more vivid and interesting. Now let me try to explain why I think so and what are my reasons.
Robots will know more, but sometimes teachers have to improvise
Only at first glance, the teacher’s work seems simple, you just need to know the topic and talk about it. But in reality this is not at all the case, just to tell is never enough for children, they are all very different, they understand differently, they think differently, they are interested in different things, and therefore each has a different approach. And no teacher can just tell once and leave, they will try to convey this topic to everyone. They will come up with different cases from life, invent stories where they can show the application of this topic. Teachers have to improvise a lot, think, and over how best to bring a lesson to children. Of course, robots will know much more, they will know absolutely everything, they are trained for this, but to bring the material in the way real people do, they will not be able.
The teacher is not just a man from school
Usually, most teachers become very close to us. And of course, this happens for a reason, children spend a lot of time with them, talk on various topics, teachers will always support and help. Many children are ready to entrust them even their secrets, which they do not even tell their parents. Robots with this will be harder, they will not have these human qualities of compassion and love. Of course, children will be interested in them, robots know everything, they can do everything, you can play with them, but they cannot become as close as real people.

Photo by Andy Kelly on Unsplash
But here are university lectures
I probably agree with the fact that robots will be able to replace lecturers. There everything happens in a completely different way as it happens in schools, in lectures lecturers just have to tell the material. And here the use of robots can be even better, they can tell a lot more material, give more arguments, tell and show without getting tired. But again, it’s worth noting that most lecturers teach the material unusually, improvise and add their own stories, which makes the classes more interesting. Therefore, replacing these lecturers may not be so easy. But in any case, it would be interesting to see how Artificial Intelligence would talk about Artificial Intelligence that creates Artificial Intelligence.
Teachers’ assistant
But to become an assistant teacher artificial intelligence can definitely become and this is the most correct way. How much time teachers spend checking homework and preparing materials for the next lessons? A crazy amount. For Artificial Intelligence it would not be so difficult. But how much time will be released from the teacher and this time he will be able to devote to his students and of course this will bring these students to a new level. Also, AI able to analyze data on each student in particulate, AI takes into account the details a human teacher could fail to notice. AI is able to provide data-based predictions of student’s identify gaps in knowledge, highlight strengths and weaknesses and suggest where extra tutoring would be of help. So that such an assistant will greatly increase the ability of the teacher.

Startups have already begun to emerge that want to create an AI robot that can become a teacher assistant. I hope soon our education will reach a completely new level and it will become even more interesting for children to learn and they will gain much more knowledge through the cooperation of technology and man. I want to say that for me this is one of the best and useful applications of Artificial Intelligence in our life.
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第415期：《黑白时代 gameboy.live》

4 5 月, 2019

开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《黑白时代 gameboy.live》
今日推荐英文原文：《Software Estimation: the art of guessing》

今日推荐开源项目：《黑白时代 gameboy.live》传送门：GitHub链接
推荐理由：一个 Go 的学习过程中产生的复古产物，可以让你重新体验一下复古的黑白老游戏。说真的，现在的塞尔达，口袋妖怪和马里奥的画面和以前已经可以说是两个世界的产物了，但是在很久以前，兴许我们更看重的是游戏性。不管怎么说，尝试一下在没有精美画面的加成下体验游戏性兴许会找到不同的乐趣。
今日推荐英文原文：《Software Estimation: the art of guessing》作者：
原文链接：https://medium.com/@katrinaprieto/software-estimation-the-art-of-guessing-f7f1c8228d69
推荐理由：没有人能预知未来，所以回答类似于“完成它还需要多久”这样的问题的时候需要一些技巧
Software Estimation: the art of guessing
As a software developer, you will oftentimes be asked the dreaded question of “How long will it take?” Software Estimation is a necessary skill in this profession and it happens to be one of the my least favourite task.

Throughout my 4 years of experience being a developer (I know it’s not a long time), I find that I still haven’t perfected the “art” of software estimation. I find myself constantly asking my managers for guidelines on how to do it properly or what thought process I should follow, in order to come up with an accurate software estimate. Well here’s the thing, it’s called an estimate for a reason. It’s never going to be accurate.

But there are several things that I’ve learned throughout the process that helped me provide an estimate that closely represents the efforts required to execute and complete a project.
It’s all in the details
Get as much details as you can about the project. Always ask questions and clarifications on the requirements. Sometimes it’s unavoidable to have assumptions and base your estimate on it. But obviously, you’ll have a much more accurate estimate if you get rid of all ambiguities.
Sizing
Your estimates aren’t necessarily going to be directly proportional to the size of the team. For example, if your initial estimate is 4 weeks to build a feature; adding one more developer doesn’t necessarily mean that the feature can be completed in 2 weeks time. The estimates should actually grow exponentially with respect to the team size. With larger teams, there tends to be a lot more time spent in communication between developers, or ramping up a new developer, and familiarizing themselves with the code base.
Break it down
It’s easier to provide an estimate for several small tasks than one big task. You’ll get a much clearer picture of the work involved if you break the requirements down into smaller components.
Historical data and personal heuristics
Chances are, there is already an existing project that is similar to the project you are estimating for. Use this as a reference and and ask the previous team members about their experience with this project. They could potentially give you an idea of how long it took them and what challenges they encountered along the way.

Typically, the estimators are chosen to provide the estimates because they are qualified or have a similar previous experience. However, there could be a time where you are unfamiliar with the technology or platform that will be used. In this case, refer to your personal heuristics i.e. make note of your learning and development style.

Someone once told me that providing estimates for a project that you are unfamiliar with, is actually to your advantage because you would be able to provide a number that already accounts for some extra padding.
Account for possible tangents to the project
Changes to the project requirements are inevitable. They happen more often than they should during the entire project lifecycle. Customers don’t usually know exactly what they want until they see what has been built. Sometimes your customer wants additional features or completely change a design which could drastically shift the priorities, and cause for the overall project direction to go off at a tangent. These changes can introduce new parameters and impact the level of effort required for development. Always give some leeway to accommodate these possible changes.
Don’t be too optimistic
Having too much optimism can lead to a highly inaccurate estimate. You need to take into account the unhappy paths. It’s better to anticipate that things might not go according to plan.
Double up
Finally, once I have my initial estimates, I usually double up the number. For example, if you estimate 1 week, then double it up to 2 weeks.

It’s common and likely that you will not be the developer working on the project that you are estimating for. Your estimates are not transferrable to other developers because everyone does things differently and perhaps the dev that will work on this, does not have as much experience as you do. Hence, other devs may take more time than what you had estimated. So it’s always good practice to add some padding and scale up your numbers.

Keep in mind that software estimates are never accurate. They are almost always wrong, so just exercise your judgement and do your best with the information that you have access to.
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第414期：《代码贪吃蛇 quinesnake》

3 5 月, 2019
开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《代码贪吃蛇 quinesnake》
今日推荐英文原文：《An intro to Algorithms (Part II): Dynamic Programming》

今日推荐开源项目：《代码贪吃蛇 quinesnake》传送门：GitHub链接
推荐理由：在假期里打发时间的不错项目——让你一边娱乐一边在代码中遨游。这可一点都没说错，你能在代码里玩贪吃蛇，如果你把那些代码都无视掉的话，这就是个普通的贪吃蛇游戏。当然了，好玩归好玩，如果你想要读懂源代码的话，还是去看那个有注释的版本比较好，你不会想在那团不明所以的东西里寻找逻辑的。
今日推荐英文原文：《An intro to Algorithms (Part II): Dynamic Programming》作者：Meet Zaveri
原文链接：https://medium.freecodecamp.org/an-intro-to-algorithms-dynamic-programming-dd00873362bb
推荐理由：介绍动态规划算法。有的时候算法会解决一些完全重复的问题——它得到相同的输入，然后拿出相同的输出。而这个算法能帮你节省下一些花在这上面的时间
An intro to Algorithms (Part II): Dynamic Programming
Suppose you are doing some calculation using an appropriate series of input. There is some computation done at every instance to derive some result. You don’t know that you had encountered the same output when you had supplied the same input. So it’s like you are doing re-computation of a result that was previously achieved by specific input for its respective output.

But what’s the problem here? Thing is that your precious time is wasted. You can easily solve the problem here by keeping records that map previously computed results. Such as using the appropriate data structure. For example, you could store input as key and output as a value (part of mapping).
Those who cannot remember the past are condemned to repeat it. ~Dynamic Programming
Now by analyzing the problem, store its input if it’s new (or not in the data structure) with its respective output. Else check that input key and get the resultant output from its value. That way when you do some computation and check if that input existed in that data structure, you can directly get the result. Thus we can relate this approach to dynamic programming techniques.
Diving into dynamic programming
In a nutshell, we can say that dynamic programming is used primarily for optimizing problems, where we wish to find the “best” way of doing something.

A certain scenario is like there are re-occurring subproblems which in turn have their own smaller subproblems. Instead of trying to solve those re-appearing subproblems, again and again, dynamic programming suggests solving each of the smaller subproblems only once. Then you record the results in a table from which a solution to the original problem can be obtained.

For instance, the Fibonacci numbers 0,1,1,2,3,5,8,13,… have a simple description where each term is related to the two terms before it. If F(n) is the nth term of this series then we have F(n) = F(n-1) + F(n-2). This is called a recursive formula or a recurrence relation. It needs earlier terms to have been computed in order to compute a later term.

The majority of Dynamic Programming problems can be categorized into two types:
1. Optimization problems.
2. Combinatorial problems.
The optimization problems expect you to select a feasible solution so that the value of the required function is minimized or maximized. Combinatorial problems expect you to figure out the number of ways to do something or the probability of some event happening.
An approach to solve: top-down vs bottom-up
There are the following two main different ways to solve the problem:

Top-down: You start from the top, solving the problem by breaking it down. If you see that the problem has been solved already, then just return the saved answer. This is referred to as Memoization.

Bottom-up: You directly start solving the smaller subproblems making your way to the top to derive the final solution of that one big problem. In this process, it is guaranteed that the subproblems are solved before solving the problem. This can be called Tabulation (table-filling algorithm).

In reference to iteration vs recursion, bottom-up uses iteration and the top-down uses recursion.

The visualization displayed in the image is not correct acc. to theoretical knowledge, but I have displayed in an understandable manner

Here there is a comparison between a naive approach vs a DP approach. You can see the difference by the time complexity of both.
Memoization: Don’t forget
Jeff Erickson describes in his notes, for Fibonacci numbers:
The obvious reason for the recursive algorithm’s lack of speed is that it computes the same Fibonacci numbers over and over and over.

From Jeff Erickson’s notes CC: http://jeffe.cs.illinois.edu/

We can speed up our recursive algorithm considerably just by writing down the results of our recursive calls. Then we can look them up again if we need them later.

Memoization refers to the technique of caching and reusing previously computed results.

If you use memoization to solve the problem, you do it by maintaining a map of already solved subproblems (as we earlier talked about the mapping of key and value). You do it “top-down” in the sense that you solve the “top” problem first (which typically recurses down to solve the sub-problems).

Pseudocode for memoization:

So using recursion, we perform this with extra overhead memory (i.e. here lookup) to store results. If there is a value stored in the lookup, we return it directly or we add it to lookup for that specific index.

Remember that there is a tradeoff of extra overhead with respect to the tabulation method.

However, if you want more visualizations for memoization, then I suggest looking into this video(https://www.youtube.com/watch?v=Taa9JDeakyU).

In a top-down manner.
Tabulation: Filling up in tabular form
But once we see how the array (memoized solution) is filled, we can replace the recursion with a simple loop that intentionally fills the array in order, instead of relying on the complicated recursion to do it for us ‘accidentally’.

From Jeff Erickson’s notes CC: http://jeffe.cs.illinois.edu/

Tabulation does it in “bottom-up” fashion. It’s more straight forward, it does compute all values. It requires less overhead as it does not have to maintain mapping and stores data in tabular form for each value. It may also compute unnecessary values. This can be used if all you want is to compute all values for your problem.

Pseudocode for tabulation:

Pseudocode with Fibonacci tree

As you can see pseudocode (right side) in an image, it does iteration (i.e. loops over till the end of an array). It simply starts with fib(0),fib(1),fib(2),… So with the tabulation approach, we can eliminate the need for recursion and simply return the result with looping over elements.
Looking back in history
Richard bellman was the man behind this concept. He came up with this when he was working for RAND Corporation in the mid-1950s. The reason he chose this name “dynamic programming” was to hide the mathematics work he did for this research. He was afraid his bosses would oppose or dislike any kind of mathematical research.

Okay, so the word ‘programming’ is just a reference to clarify that this was an old-fashioned way of planning or scheduling, typically by filling in a table (in a dynamic manner rather than in a linear way) over the time rather than all at once.
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第413期：《微信小程序 mini-github》

2 5 月, 2019

开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《微信小程序 mini-github》
今日推荐英文原文：《Key Tips to Choose the Ideal Database Solution for Your Mobile App》

今日推荐开源项目：《微信小程序 mini-github》传送门：GitHub链接
推荐理由：GitHub 之前有过像样的微信小程序——虽然已经停止运行了，这个是一个新的小程序。你可以像平时一样翻 Trending，翻 issue 等等，尽管用在工作上的效率比起电脑浏览器来说还是低了不少，不过平时利用碎片时间看一看新出现的项目来长长见识的话这会是个好选择。
今日推荐英文原文：《Key Tips to Choose the Ideal Database Solution for Your Mobile App》作者：Juned Ghanchi
原文链接：https://levelup.gitconnected.com/key-tips-to-choose-the-ideal-database-solution-for-your-mobile-app-5e6ecb52af93
推荐理由：但凡是要存点东西的 app 都可能用得到数据库，这篇文章就是选择数据库时的一些小 tips
Key Tips to Choose the Ideal Database Solution for Your Mobile App
What is a database for a mobile app? It is basically responsible for keeping all the user information and making them available at the right time and the proper context. Naturally, using the right kind of database is very important to secure user data and deliver a rewarding experience.

As far as choosing the right database technology is concerned, there are some considerations that every mobile app developer should go through. Here we are going to explain some of these considerations.
The choice isn’t just limited to SQL vs NoSQL
You probably have come across various posts on the pros and cons of the SQL and NoSQL database, and you often think these are the two main database options to choose from. But seriously, choosing the database isn’t just limited to this duality between SQL and NoSQL. There are several other things to consider.

The app developers need to choose a database with right size, structure and performance to support the demands of the app in question. • The database structure basically is all about how you choose to store and retrieve the data at the time of the need. Choosing the right database depends on finding the appropriate structure to deal with the type of application data. Often by selecting the database with appropriate structure, you can reduce the development efforts to a minimum. • The database size refers to the capacity of the database for storage and retrieval. A database with advanced partition system can easily store data across multiple systems and servers. • Database speed and scalability refers to the time taken by the database in reading and writing the data. While there are databases characterized to serve read-heavy apps better, there are several others that are appropriate for write-heavy apps. When choosing a database for your application, you need to go through all these considerations instead of choosing just a SQL or NoSQL database.
Data Safety and Security
The second significant consideration is ensuring optimum safety and security of the data. When your application needs to use decentralized data storage with synchronize accessibility, you must have proper data security in place to ensure an appropriate authentication and have to address the needs for restful data, data in motion and accessibility for reading and writing.

When it is about the authentication, it needs to be flexible, and you need to integrate public, custom or standard authentication providers. Offering a secure file system and data-level encryption is also essential to secure restful data at both servers and client-side.

When it comes to data in motion, security must be ensured through secure channels like TLS or SSL. At the same time, the database must offer all appropriate controls to allow users interactions with accessible and modifiable data.
Using a Flexible Data Model
Using the right data model is really a mission-critical consideration for the app developers. The right data model ensures how well the database can be integrated with the app. The right model also ensures how over time it can go through changes with the evolving requirements.

Data modelling basically help the developers to map all the features of an app into the data structure. The model will easily allow you to see all the entities and their related aspects and their corresponding relations. When fitting your app data into the structure, you easily know the appropriate structure for your app.

Let’s have a look at the vital database models.

Relational database model: This model classifies data through tables, and each table consists of rows. Data keys identify these tables and their constituent rows. These keys help relating multiple tables of data and help to access data as per the contexts or requirements.

Document-based: This database model basically stores data in a structure made up of fields with simple or complex values. In such a database, each document can be represented through different fields. Such database by supporting complex hierarchies of documents allows embedding them inside the apps. This type of data model is not limited to fixed schemas are preferred by developers for flexibility.

KeyValue-based: Key/Value-based database systems are known for simplicity and easier accessibility. As per this system, data values are stored with unique keys.

Column-based: Column-based databases work much like the relational database systems and keep data stored in rows and columns. The columns of data can have multiple values. The data can be fetched either by row or column as per the required type of data.

Graph: Graph-based database model actually stores data entities governed by their internal relationships. For easy navigation across various data entities and retrieving data through the relationships, this storage type comes with great help.
Resolving Data Conflicts
Last but not least of all critical considerations regarding the choice of the database should be resolving the data conflicts. Just because in the context of mobile apps, some data can be modified simultaneously by several different devices, conflicts between data versions is a common issue. This is why developers need to choose a database with a robust system to resolve such conflicts.

The resolving conflict system of the database has to be flexible and accommodating as well. The resolution of conflicts should be carried across devices, users, cloud systems and other third-party integrations. Conflict resolving should work differently in various systems.

As of now, a system like the Couchbase Mobile seems to be an ideal solution as it addresses the differences with the revision trees ruled by the protocol of picking the most active branch. Instead of clock based systems where clock differences across different devices are a common issue, this revision tree model is ideal for conflict resolution for mobile apps.
Conclusion
All the tips mentioned above concerning the choice of the right database system can work hand in hand to help you pick the ideal model, structure, security and conflict resolution for your application.
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/