开源日报 - Page 96 of 262 - Open Source Daily

开源日报第658期：《spring boot demo》

2 1 月, 2020

开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《spring boot demo》
今日推荐英文原文：《A Brief History of Open Source Software》

今日推荐开源项目：《spring boot demo》传送门：GitHub链接
推荐理由：spring boot demo 是一个用来深度学习并实战 spring boot 的项目，目前总共包含 65 个集成demo，已经完成 52 个。该项目已成功集成 actuator(监控)、admin(可视化监控)、logback(日志)、aopLog(通过AOP记录web请求日志)、统一异常处理(json级别和页面级别)、freemarker(模板引擎)、thymeleaf(模板引擎)、Beetl(模板引擎)、Enjoy(模板引擎)、JdbcTemplate(通用JDBC操作数据库)、JPA(强大的ORM框架)、mybatis(强大的ORM框架)、通用Mapper(快速操作Mybatis)、PageHelper(通用的Mybatis分页插件)、mybatis-plus(快速操作Mybatis)、BeetlSQL(强大的ORM框架)、upload(本地文件上传和七牛云文件上传)、redis(缓存)、ehcache(缓存)、email(发送各种类型邮件)、task(基础定时任务)、quartz(动态管理定时任务)、xxl-job(分布式定时任务)、swagger(API接口管理测试)、security(基于RBAC的动态权限认证)、SpringSession(Session共享)、Zookeeper(结合AOP实现分布式锁)、RabbitMQ(消息队列)、Kafka(消息队列)、websocket(服务端推送监控服务器运行信息)、socket.io(聊天室)、ureport2(中国式报表)、打包成war文件、集成 ElasticSearch(基本操作和高级查询)、Async(异步任务)、集成Dubbo(采用官方的starter)、MongoDB(文档数据库)、neo4j(图数据库)、docker(容器化)、JPA多数据源、Mybatis多数据源、代码生成器、GrayLog(日志收集)、JustAuth(第三方登录)、LDAP(增删改查)、动态添加/切换数据源、单机限流(AOP + Guava RateLimiter)、分布式限流(AOP + Redis + Lua)、ElasticSearch 7.x(使用官方 Rest High Level Client)。
今日推荐英文原文：《A Brief History of Open Source Software》作者：Andy Updegrove
原文链接：http://www.consortiuminfo.org/standardsblog/articles/brief-history-open-source-software
推荐理由：今天，在互联网时代，每个人都在享用开源软件的便利，也有数以万计的程序员为开源软件作出贡献。开源软件也有它独特的历史，让我们一起了解一下。
A Brief History of Open Source Software
In the early days of information technology (IT), computers were delivered with operating systems and basic application software already installed, without additional cost, and in editable (source code) form. But as software emerged as a stand-alone product, the independent software vendors (ISVs) that were launched to take advantage of this commercial opportunity no longer delivered source code, in order to prevent competitors from gaining access to their trade secrets. The practice also had the (intended) result that computer users became dependent on their ISVs for support and upgrades.

Due to the increasingly substantial investments computer users made in application software, they also became “locked in” to their hardware, because of the high cost of abandoning, or reconfiguring, their existing application software to run on the proprietary operating system of a new vendor. In response, a movement in support of distributing human-readable source code as well as the legal right to modify, share and distribute that code, together with the usual, machine-readable object code, emerged in the mid-1980s. The early proponents of such “free software” regarded the right to share source code as an essential freedom and created licenses – notably, the GNU General Public Licenses – that required vendors to give back their own innovations to the project community. Those who espoused this view are usually referred to as being part of the “free software movement.” A later faction focused only on the practical advantages of freely sharable code, which they called “open source software” (OSS), leading to adherents of that group becoming known as the “open source movement.”

Concurrently, the Internet enabled a highly distributed model of software development to become possible, based upon voluntary code contributions and globally collaborative efforts. The combined force of these developments resulted in the rapid proliferation of millions of both free software and OSS development projects that have created many “best of breed” operating system and application software products. Today, virtually all proprietary software includes open source software, and an increasingly large percentage of crucial software platforms and programs are entirely open source.

While terms like “free software” and “open source software” may sound innocuous, when properly understood they imply elements of political philosophy, revolutionary zeal, technical development methodologies, traditional as well as radical legal theories, and cold, hard business pragmatism. Needless to say, such a rich stew of attributes is likely to present something of a challenge to anyone interested in gaining a quick understanding of exactly what this phenomenon is all about.

The reasons for investing the time to gain a better understanding of free and open source software (FOSS) are several. From a socio-political point of view, the FOSS movement is part of a broader, socio-political initiative, energized in part by the ability of the Internet to enable the sharing of information and the active collaboration of people on a global basis. In the case of the free software movement, that movement questions the utility and fairness of many traditional copyright and patent-based legal restrictions, and seeks to liberate software for the benefit of all. Unlike proponents of OSS, who primarily wish to permit open source software to be freely available without traditional proprietary constraints, free software advocates support a set of ethical rules intended not only to foster free access, but also to inspire — and in some cases require — those that benefit from such access to contribute their own modifications and additions back to the community of developers as well.

From an economic point of view, the OSS development model has reordered the business realities of software development in multiple ways. For a software vendor or user, the per-business costs of development of a given piece of software can be radically reduced by participating in a development project in which many others contribute their efforts as well. For an end user, access to the source code of an OSS product grants independence from a proprietary vendor, since the end user can adapt the code, or put development work out for competitive bidding. For commercial intermediaries, efforts can be directed towards developing value added services on top of core code that is available for free and maintained by a community of developers. For policy makers, OSS offers opportunities to level the playing field for domestic vendors while lowering costs of procuring public IT systems. From a marketplace perspective, the OSS model presents a disruptive force that offers opportunities for both existing as well as new businesses to attack the dominance of entrenched market participants whose advantages rest on proprietary development and sales models.

Today, FOSS has become so pervasive that effective IT procurement and management requires a working knowledge of what FOSS is all about. Active participants in the development and use of FOSS products additionally need to know how FOSS can be expected to evolve in the future, and how the legalities of FOSS apply to anyone that participates in the development of FOSS, uses a FOSS product, or embeds a FOSS code in their own products for resale.

In this article, I will provide an overview of the history of FOSS and its champions, the major philosophical differences that differentiate free software from other open source software, the multiple licenses under which FOSS is made available, and the principal non-profit institutions that support and promote FOSS. I will conclude with a brief bibliography of primary FOSS sources for those that wish to learn more than this necessarily superficial review can hope to provide regarding such a rich and complex topic.

OSS: The Basics
What exactly does someone mean when they speak of free or open source software?

What it is (and what it isn’t): The answer is not only “it depends,” but that it depends a lot more than one might think. Depending on the context, it may imply a broad spectrum of information, covering topics as varied as legal rights and obligations, affiliation with social movements, and mode of development. In other words, the words “open source”, and in particular, “free software”, may mean many things at once.

At the most basic level, the term OSS is sometimes used to refer, albeit incorrectly, to a piece of software for which both machine readable (object) and human readable (source) code is supplied to the user. And sometimes, this is all the person using the term intends, as when a single developer creates a piece of code and then posts it to the Internet at a public site with few, or no, restrictions on its reuse.

A popularly used OSS program, however, is likely to have additional attributes that differentiate it from proprietary software. Most likely, it will have been developed and be maintained at a public web site that allows any interested programmer to sign up and offer to help, whether by pointing out bugs and suggesting ways to fix them, by actively participating in development of additional code, or by helping document or promote the ongoing work of others as it happens.

The project in question may have been started by a single individual, or by a group of individuals, or it might have been launched when a proprietary vendor released the object and source code to a product that it had developed, concluding that it would gain greater benefit as a result of doing so (e.g., by having continuing access to the same code at a lower cost, due to the labor contributed by non-employees, or by selling support services to the users that download the program for free).

Frequently, multiple projects will collaborate to create software “stacks” that together provide an essential service. When they do, each project creates a single layer while coordinating in real time to ensure that each layer is technically interoperable and tightly integrated with the others.

Until FOSS became ubiquitous, most computer users spent their entire lives in the locked-in “Win-Tel” platform world that sprang from the marriage of Microsoft operating systems with Intel processors. In the realm of application software, most of the same users still live (when it comes to office productivity tools) in the same convenient, but constrained world of Microsoft Office. Convenient, because almost everyone else continues to use Office, and text documents and spreadsheets can therefore be easily exchanged among other Office users. But constrained, because once a user enters the world of Office, it is difficult to leave.

Legally, the term OSS at minimum implies that anyone can download the code with the freedom to do whatever they want with it, so long as they do not try to sue the developer for any flaw in the code or infringement of the rights of any third party and acknowledge the copyright of the original code author in her code. The “copyleft” software licenses (described in greater detail below) generally associated with the free software movement have additional, more restrictive terms. Anyone that changes copyleft-licensed code and sells the modified version must make their modifications available to all under the same copyleft license terms as a matter of ethics and morality, as well as in response to a legal obligation.

What OSS is not is an infringement on any developer’s rights, a second best alternative to proprietary code, or a security risk to the enterprise.

And it certainly isn’t a passing fad. OSS is here to stay.

The value proposition: While the value of free software for the customer sounds obvious, there are benefits beyond the lack of a license fee. Briefly stated, they are as follows:

For the customer: Under the traditional consumer software licensing model, individuals typically incurs a one-time cost to acquire proprietary software and are then on their own, whereas commercial customers are likely to make a more substantial investment in additional services, such as purchasing training for their employees to learn how to use the new software, and also ongoing “support” services (i.e., ensuring that there is someone at the end of the phone if problems are encountered installing, integrating, or operating the software on complex enterprise systems), as well as “maintenance” rights to ensure that they will get updates (e.g., bug fixes and improvements) after the software has been installed. They may also need to pay for hardware upgrades in order to be able to run new software, and pay consultants and other service providers to plan and complete the upgrade.

The aggregate of all of these fees is the “total cost of ownership” of a given software package, and the sum of these additional costs can be substantial. Similarly, while some FOSS may be free (e.g., the OpenOffice and LibreOffice productivity suites), a customer may decide to buy a proprietary product instead.

While the total cost of ownership of a FOSS product will generally be cheaper, there are other advantages to using FOSS instead of proprietary products. They include:

Access to code: When a customer installs proprietary software, it becomes entirely dependent on the vendor for the code’s improvement and performance, because the customer has neither the technical means (access to source code) nor the right (legal permission) to alter the code. If the customer needs new or different features, or needs an update to maintain compatibility when switching or upgrading other systems, the vendor may or may not be willing to customize the program (either at all or at a price the customer is willing to pay). If the vendor discontinues support for the product, or goes out of business, the customer is stranded. In contrast, a customer with a FOSS alternative has the ability as well as the legal right to change the code any time it wants to. It can also hire anyone it wishes to help it change or maintain the program. If the project that created the code goes dormant, a customer may be disappointed, but it won’t be stranded.

Freedom from lock in: While open standards increasingly give customers protection from “lock in” (i.e., dependency on a single vendor, and the certainty of significant switching costs if they wish to change vendors), changing from one product to another can still be difficult and expensive. In the case of systems based on Linux, the OSS operating system that has become predominant in use cases as diverse as telecommunications, automobiles and nuclear power plants, there are multiple independent “distributions,” all based on the same core software (the Linux kernel).

Release cycles and bug fixes: Well-run OSS projects are in constant motion, upgrading and fixing bugs in real time. Customers can access this work on a far more frequent basis than users of proprietary products, who must wait until the vendor decides to incur the costs of making a minor or major release. Because the source code to OSS is available to the customer, popular OSS software also generates a flood of bug reports and suggested fixes, which are evaluated on a constant basis and implemented as appropriate. Or, as stated in what is often referred to as “Linus’s Law” (as in Linus Torvalds, the originator and ongoing leader of Linux kernel development): “Given enough eyeballs, all bugs are shallow.” In contrast, proprietary vendors who receive complaints from customers must seek to replicate and diagnose the problem before they can fix it.

Security: While it may seem counterintuitive that code visible to anyone anywhere would be safer to use, popular OSS programs are in general acknowledged to be more secure, largely for the same reasons just stated: because anyone can see the code, anyone can track down the source of a vulnerability, let project managers know of the cause of concern, and/or propose a fix herself. As a result, security issues can typically be identified, fixed, and propagated to all users faster than flaws in proprietary code. As a result, OSS is increasingly being used by defense, financial and other users who place the highest priority on security. That said, where the numbers of eyes are small, open source can be as vulnerable as proprietary code. The Linux Foundation (LF) is currently working to identify similar situations and provide funding to correct them.

For the developer: It is important to note that much of the code contained in many FOSS products is created by individuals participating on a volunteer basis rather than at the instruction of their employers. Such individuals participate without compensation for many reasons, including enjoyment, challenge, gaining status within the project community, and gaining valuable job skills that enhance marketability and compensation potential. Individuals that rise through the ranks of prominent FOSS projects can dramatically enhance their professional credentials, as corporations are also major contributors to FOSS projects and skilled FOSS developers are in high demand.

Points of origin: Those learning about FOSS for the first time are often puzzled that there is usually no physical “there” there, in the sense of a central development facility. This is hardly surprising, because in most cases there is no person or legal entity that owns more than a small percentage of the code in an OSS product, or that is responsible for creating or maintaining the code (the Linux kernel, which is created by a global network of thousands of individual developers, is a prime example). Instead, the code may simply be hosted in the cloud, usually for free, by an organization formed for that purpose, which also provides a variety of supporting tools and services.

Other projects are supported by non-profit foundations formed to support them (e.g., the Mozilla Foundation, which supports the Firefox web browser), or by so-called “umbrella organizations,” such as the Apache, Eclipse, and Linux Foundations, which host from scores to hundreds of FOSS projects. A small number of FOSS projects is supported by for-profit corporations, such as Red Hat and Micro Focus International, which host the Fedora and SUSE Linux distributions, respectively. They profit by offering paid support services along with these unique Linux-kernel based distributions.

While selling services on top of FOSS (or increasing profits as a result of using FOSS) are popular ways to benefit from FOSS economically, they are not the only ones. Simply sharing the development costs of software with other companies needing the same software tools and platforms lowers the overhead per vendor. And, just as collaboratively developed open standards permit competitors to vie with each other in other ways (e.g., by developing and selling proprietary features and services offered above the level of standardization), FOSS can enable entirely new and competitive business opportunities. A current example can be found in the mobile device marketplace, where the majority of mobile phones today run on variations of the Google-developed Android operating system, which is itself based on the Linux kernel. Google profits from its ability to ensure that mobile platforms can attractively display Google ads and support other Google software and services; mobile device manufacturers can sell more phones at lower prices due to greatly reduced software development costs; and silicon vendors can sell far more chips due to the rapidly expanding number of people who own mobile devices.

下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第657期：《GitHub》

1 1 月, 2020

开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《GitHub》
今日推荐英文原文：《11 of the Best New Year Marketing Ideas to Jump-Start Your 2020》

今日推荐开源项目：《GitHub》传送门：GitHub链接
推荐理由：GitHub……某种意义上其本身就象征了开源精神，这次我们就来介绍一下它吧。GitHub 是通过 Git 进行版本控制的软件源代码托管服务平台，现在托管于它之上的项目早已不计其数，基于这些项目之上的开发者交流更是从未间断，说它成为了日常中的一部分也不为过。你只需要创建一个公开仓库，然后放入你的代码，就可以与所有 GitHub 使用者分享它们，不断的有新的开源项目在这里产生，发展，成为焦点或是不为人知，但是博取眼球可能并不是开源一个项目的最终目的——思维与思维碰撞，产生新的知识，在这一点上，开源软件比闭源软件更容易做到，能在这里获取知识兴许才是 GitHub 成为开发者日常的原因。

今日推荐英文原文：《11 of the Best New Year Marketing Ideas to Jump-Start Your 2020》作者：Shane Barker
原文链接：https://medium.com/better-marketing/11-of-the-best-new-year-marketing-ideas-to-jump-start-your-2020-d52c1f0295c6
推荐理由：如何利用新年到来之际想办法吸引顾客，毕竟还是要吃饭的嘛
11 of the Best New Year Marketing Ideas to Jump-Start Your 2020
As 2019 draws to a close, we’ll soon be approaching a new year. While it may mark the end of the holiday season, it’s not the end of your marketing campaign. What better way to close out the year than with a festive promotion that will boost your sales?

Consumers will already be in the holiday shopping spirit and a good promotion can further encourage them to buy from you. Even if you haven’t started ideating, it’s not too late. We’ve got several New Year marketing ideas through which you can boost your business.
Best New Year Marketing Ideas for 2020
Move over, cliches like “New Year, New Me.”

Taglines like these won’t win you customers. It’s time to give your marketing campaign a refreshing twist. To help you crush your New Year marketing promotions, we’ve got some tips for you.

Following is our list of the top New Year marketing ideas that you can use to grow your business.
New Year Marketing Idea #1: Send a New Year email
When it comes to New Year marketing ideas, there is nothing easier than sending an email. There’s no better way to ring in the New Year than by wishing happiness to the people you care about. For a business, these people are your customers. You need to show them that you care through your New Year’s greetings.

If you want to stand apart from the rest, you can even send an email before the New Year instead. There are greater chances of it being noticed, as people’s inboxes are usually flooded with emails on New Year’s Day.

It’ll also make consumers feel that your brand prioritizes them and cares about them. This way, you can use email marketing to your advantage.

To further sweeten up the email, you can add a discount code or include an offer in your email. You could also organize a giveaway contest for a select few, loyal customers.

Make sure they know that you’re doing this exclusively for them so that they feel special. This can help increase your brand loyalty.

New Year Marketing Idea #2: Launch new products
One of the most popular New Year marketing ideas is to launch new products at the start of a new year.

A great new year’s marketing idea would have heavy advertising campaigns throughout December, which will eventually lead to the product launch. You can launch the product as soon as the clock hits midnight.

This post-midnight sale can be a great way to sell your new product. The sale must explain what the new product is and how it is better than the past products. You must also try to offer customers a deal on their first purchase.

Additionally, you can offer discounts on your older products too. Alternatively, you can conduct special New Year giveaways as well. New Year marketing ideas such as this one can help you generate buzz around your brand.

Reebok, for instance, created a “New Year, New Gear” promotion through emails. The idea was to sell their new workout gear.

New Year Marketing Idea #3: Welcome the New Year on social media
Social media is definitely one place where you cannot miss out on marketing. You want to get your brand noticed all over social media, and the New Year is a great time to do so.

You can use social media to get your customers excited about your brand in 2019. This is why welcoming the new year on social media is third on our list of top New Year marketing ideas.

With the new year, you can come up with a new avatar for your brand on social media. This can definitely catch the attention of your followers and increase brand awareness. It’ll also put your brand’s name on the top of their minds at the right time so that you can start off strong in the new year.

You can also use social media for marketing new products that you may be launching on New Year’s Eve. And if you have products specific for New Year’s, you can promote them through social media. New Year marketing ideas such as these can help your business get traction. Not only will your sales increase but so will your brand awareness.

PayPal, for example, wished their followers a Happy New Year in a simple manner on social media.

New Year Marketing Idea #4: Run a quotes contest
New Year’s Day is also the day when people make resolutions. Many people make resolutions at the beginning of the New Year. While the resolution of every person is unique, each resolution needs inspiration. One of the more unique New Year marketing ideas is to run a quotes contest.

For this, you can host a contest on inspiring quotes. In this contest, your customers can post quotes that inspire them and share them. A great place to host this contest would be on social media. It will help generate buzz for your New Year announcements.

You can ask fans to share their quotes on all social media platforms. Additionally, you can come up with a unique branded hashtag as well. This can further help increase brand awareness.

Ask customers to get as many likes, comments, and shares on their posts and use these metrics to select the winners. Based on the engagement, you can then give them cool prizes. You can even ask them to share their experience of the contest with you and post that on social media as well.

The best part about this New Year marketing idea is that you’ll get loads of quotes. You can compile them and share them with your audience. This will make them want to keep coming back to you whenever they need some inspiration.

You can also launch other forms of contests such as a countdown contest. In such a contest, you can ask your followers to come up with their own versions of the countdown to midnight.
New Year Marketing Idea #5: Go traditional
New Year marketing ideas shouldn’t be just restricted to online marketing. While you may be doing a cracking business online, it’s a great idea to incorporate traditional marketing as well.

If you have a brick-and-mortar presence, you can deck up your display window with a New Year’s theme. This is one of those underrated but important New Year marketing ideas that you should implement this festive season.

This could be something like a New Year’s party theme in which your products are being used. It’s sure to catch the attention of people passing by. You can even choose to place posters and banners at places with high visibility.

This could include places such as malls and shopping markets where people go to buy New Year’s goodies. If they see your banners there, your products may just stick in their minds. This can help you generate brand awareness, which could eventually result in sales.
New Year Marketing Idea #6: Have a New Year’s Day sale
Even if you’re not launching a new product, it’s a great idea to have a special sale on New Year’s Day. The promotion should ideally be New-Year-centric to generate buzz among consumers.

While your holiday sales may have just ended, there may be customers who are waiting for better bargains. This is a great time to give those customers a shot at buying your products. Flash sales are amazing New Year marketing ideas, and they can help you clear out your holiday inventory.

The customers who purchase during these flash sales may not end up becoming repeat customers. However, they can definitely be used to your advantage to get rid of unnecessary inventory in a way that’s not wasteful.

To give your sales a boost in 2020, you can give out discount coupons to your customers during the sale. This can even help increase brand loyalty.

Dillards, for example, has a New Year’s Day clearance sale. During this period, they sell products at huge discounts

New Year Marketing Idea #7: Have a New Year’s party
No list of New Year marketing ideas could be complete without a New Year’s party idea. Parties and New Year’s Eve are synonymous. Everyone wants to ring in the New Year with some sort of celebration. Pubs and restaurants charge a fortune to attend a New Year’s Eve party. However, not everyone wants to shell out so much cash to celebrate.

You can use the occasion to your advantage by throwing a party for your loyal customers. The party doesn’t necessarily need to have DJs and a special menu. It can be anything related to your business. For instance, you could let the guests try out your latest products at the party.

These events end up giving a memorable experience to your customers. Such New Year marketing ideas can go a long way to help you to increase brand loyalty. Just make sure that you advertise the event well. Be it on social media or brick-and-mortar locations, such events can be a big draw for people.

You could even partner with influential names to host or promote the party. Ciroc, for example, collaborated with Sean Combs for their ads. He even hosted a New Year’s party with the hashtag #CirocTheNewYear. This party was sponsored by them and helped them reach out to more people too.

New Year Marketing Idea #8: Make a 2020 calendar
Another one of the top New Year marketing ideas is to make a calendar for the coming year. Consider creating a customized calendar and sending it out to your loyal customers. You could even offer this as an add-on to your customers’ holiday purchases.

The best part about the calendar is that your customers can use them throughout the year. This can help keep your business at the top of their minds all year long. This is one of the most easy-to-implement and simple New Year marketing ideas that can help you grow your brand.

For instance, Betabrand created a pantsuit calendar in 2018. This calendar featured their popular dress pant yoga pants.
New Year Marketing Idea #9: Launch a post-New-Year sale
Sales do take a dip after the holiday season. To keep the momentum going, here is a tip: Launch a post-New-Year sale. This sale can start off 2020 with cool offers, and you might be able to attract customers to your brand.

Even if you don’t want to try something fancy, you can have a simple promotion that offers a fixed discount. You can advertise the promotion through social media and other modes of marketing as well.

This type of promotion may not get as many sales as you may get during the holiday season because people have been spending so much already. However, it can still help you reduce the dip in sales that takes place as you enter the new year.

For example, Rifle Paper Company created a gift guide for the New Year. They sent out emails about the guide to their customers along with a discount code. The promotion ran into the new year as well and helped them with their sales too.

New Year Marketing Idea #10: Cater to impulse purchases
When you make a lot of sales during the holiday season, make sure you’re prepared for the post-holiday returns. Many of the products that you have sold may be returned by the customers due to varying reasons.

When customers return items, you need to come up with methods to cater to their impulse buying decisions. Whether you’re a brick-and-mortar store or an e-commerce store, you need to come up with a strategy.

Think about everything that a customer might need during their returns. You can then put up all these items at locations where they go to return their purchases. For every return that they make, you can encourage them to purchase some other product. This may just get them to buy it on an impulse.
New Year Marketing Idea #11: Have a body-positive promotion
Last, but not least, on our list of New Year marketing ideas, is to run a body-positive promotion. A lot of New Year’s resolutions are weight-related. In fact, about 45% of Americans wanted to lose weight as a part of their resolutions for 2018. Having a promotion that specifically targets this group of customers can work greatly in your favor.

You can create an atmosphere where your customers will be empowered to love their body as it is. At the same time, you can promote a healthy lifestyle through the promotion. You can run promotions of clothes of all sizes and even market them in such a manner.

ModCloth, for instance, markets their clothes with photos of models of all sizes. This helps send out a positive vibe to the customers.

You can even add products to your promotion that will help customers reach their resolution goals. For instance, an electrical appliances brand can advertise smoothie makers that can help improve diets.

Make sure that you share these promotions through all the modes of marketing available. You must also make sure that the promotion is for a specific product that is related to the resolution. By highlighting its benefits and offering a discount, you can push the customers to take action.
Final Thoughts
New Year’s Day may seem like the end of the previous year and the end of the holiday season. However, with effective New Year marketing ideas and strategies, you can make the most of this occasion. Launching promotions, contests, new products, and New Year’s greetings can go a long way to build your brand’s image and boost sales.

Which New Year marketing ideas have you implemented in the past? Let us know your innovative New Year marketing ideas in the comments section below.
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第655期：《加猫 nyan-progress-webpack-plugin》

31 12 月, 2019
开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《加猫 nyan-progress-webpack-plugin》
今日推荐英文原文：《Simplicity Over Complexity!》

今日推荐开源项目：《加猫 nyan-progress-webpack-plugin》传送门：GitHub链接
推荐理由：webpack 作为应用打包器来说家喻户晓，它的插件也多如牛毛。这个项目同样也是一个 webpack 的插件，但是不同于其他插件，它最大的特点就是只会往你的命令行输出里加彩虹猫……对，真的只是加猫而已，它能做的就是让你表明自己对彩虹猫的信仰，以及向周围的人宣传猫猫的伟大之处。

今日推荐英文原文：《Simplicity Over Complexity!》作者：Ines Panker
原文链接：https://medium.com/better-programming/simplicity-over-complexity-8b4172fd5e8b
推荐理由：大道至简，科学的最后总是化繁为简的，在复杂和简单之间需要一个平衡点
Simplicity Over Complexity!

Or is it the other way around?
Today, I came to two realizations, both of them surprising and both of them essential. During an innocuous debate about code review, I suddenly discovered that only a few basic ideas underlie all of my coding-related decisions. One of them is: Simple is better than complex. And about three seconds later, I realized that this is neither a well-known mantra nor one that can be quickly explained. It’s a conviction that you grow into. But without having to wait for a few years, how do I explain it to my teammate?

To me, “simplicity over complexity” is a pragmatic answer to questions of many flavors, a simple Occam’s razor. It gives me two benefits:
- It lets me separate a problem into the part that I need to solve now and the part I can postpone.
- It gives me confidence in my decision because it is backed up by so many other theorems, principles, rules, and guidelines.
So What Does “Simple Is Better Than Complex” Even Mean?
This guideline wants you to gravitate towards simpler solutions. You are meant to ask yourself often: Could you simplify your code and still achieve the same result? Could you simplify the design and still achieve the same goal?

It can be small things like: Are you overusing powerful language structures? Do you benefit from using a try- except statement, or does a simple if statement fit into your flow better?

Or it can be larger things like: Should you really support 20 different scenarios, or can you achieve a comparable user experience by providing just the most common three?

This guideline coaxes you to be vigilant about complexity and to demand good reasons for increasing it.
How Complexity Influences a Project
At the beginning of a project, there is no code, no specs. The future (the things we will have to create) is daunting, but the past (the things we did create) is simple. We’ve created nothing so far, and that was very simple; anybody could have done it ?.

Now we need to create something. We can’t create everything at once; what should we start with?

If we trust the booming startup scene, the pragmatic way is to start with an MVP. MVP stands for minimum viable product, a product with just enough features that it is useful, that it successfully completes its main task. The goal at this stage is to keep the costs of developing the project low until we have proof that we are developing the right features.

The MVP principle is just different phrasing for “simple is better than complex.” The simplest solution that solves your problem should be used. Do not increase complexity (i.e., costs) until you have good reasons to.

A similar concept is present in the Pareto Principle, which is also called the 80/20 rule or the law of the vital few. The Pareto Principle states that for many events, roughly 80% of the effects come from 20% of the causes, i.e., 80% of bug reports are caused by 20% of bugs; 80% of the time, 20% of the features are used.

The Pareto Principle originated in statistics, in economics, but has been applied to a wide range of topics. It supports our Simplicity over Complexity concept very well. Why bother supporting every conceivable workflow for our software if 80% of our customers use just 20% of the possible workflows?

Thus, to determine which features to develop first, we must be picky. Everything we build, we will also have to support for some time. Everything we add to our software will have a cost of maintenance and will influence how and at what cost we can build other, completely unrelated, new things.
What Is a Good Reason to Increase Complexity?
On paper, all of the above seems logical. But it is also very vague. There is nothing even resembling an actual definition of either complexity or simplicity, nothing we can use as a rule of thumb to judge which feature is worth a month of effort, which six months, which just a day. And this is where the fog commences and the bickering becomes intense.

The real reason developers and managers don’t care for this guideline is that we don’t agree on the meaning of “simple.”

If I’m at a meeting and our biggest customer convinces me they will leave our company if we don’t deliver X by the end of the quarter, then to me this will seem like an “our-company-is-on-the-line” insanely good reason to increase complexity.

If, however, I am a new developer on the project, and I can see the software all scarred from botched passed projects, I might also be convinced that if we do not act now and start paying for our past misjudgments, then this project is doomed either way.

So what do we do?

We plan ahead.

This situation might be unsolvable. The most efficient way to resolve it is to avoid it. We don’t want to be in the position where the complexity has grown so much that we are having difficulties maintaining this project.

As long as a project is simple, it is easy to add more people to it and, crucially, it is easy to remember all the scenarios we are covering.

The more complex a project is, the longer it takes for new people to help meaningfully. The project becomes more and more dependant on its original authors, the only ones who still know what complexity was added where and why. But the project also becomes more and more buggy because of forgotten features and flows. And as it becomes more buggy, it also uses flexibility. A significant number of bugs sooner or later become features. Users don’t know which functionalities were intended and which were not. They start relying on the broken functionality, and every change from here on is a broken promise.

Interestingly, teams sometimes use tests to alleviate this problem. Even if something was unintentional, as long as a test is asserting it, it will alarm us if we accidentally change the logic. But I would argue that this is a futile defense. Very few tests are properly read, understood, or maintained. Such tests are just like sending perpetual drunken border officers to the border. We see them, but we do not take them seriously.
Is Every Exception Evil?
On the other hand, when we write our code, we want it to be used by real-life people in real-life problems. Now, show me one problem in nature that has a clean, easy solution with no exceptions! There are none. Life is complicated and so is code.

It is only in theoretical settings that we can “ignore the air-resistance in this physics formula.”
And Still, Simplicity Is Better
And still, we need to know what the ideal is. We need to know what we are striving for so that we will know when we bend away from it so that we might know why we’ve bent away from it.

There is no magic solution; there is no three-step guide. Whether a good balance was struck between simplicity and complexity only becomes evident later on. Once made, the decision is often unchangeable or expensive to change.

But if we plan to continue working on some project for at least a bit longer, we should think of our future selves, who will have to live with this decision.

Is this feature really good in the long run?
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第656期：《YTB DevYouTubeList》

31 12 月, 2019
开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《YTB DevYouTubeList》
今日推荐英文原文：《Stop Testing Code You’ve Already Written》

今日推荐开源项目：《YTB DevYouTubeList》传送门：GitHub链接
推荐理由：YTB 上你能看到几乎所有想看的玩意，总会有人去做它们的。这个项目收集了 YouTube 上与软件开发有关的频道，包括开发教程或者是编程直播之类的，下次可以考虑拿这个来打发时间下饭之类的（我可没试过拿这些下饭），当然了大部分的资源都是英语，至于你要问有没有非英语……只有俄语可以吗？

今日推荐英文原文：《Stop Testing Code You’ve Already Written》作者：Jamie Morris
原文链接：https://medium.com/@maloric/stop-testing-code-youve-already-written-750773b9bb5b
推荐理由：测试也是一步一个脚印来的，这篇文章介绍了测试驱动开发的优点
Stop Testing Code You’ve Already Written

Test One Step at a Time, Not One Mountain at a Time
It’s that time of year where we start to make promises that we’ll probably just forget by February. New Years Resolutions are usually well meaning but we are usually trying to solve the same old problems in ways we’ve tried before. Eat healthy. Go to the gym more. Learn a new language. Write more unit tests.

Every time I talk to a team that’s struggling and ask them what they’ll do different next time, I always get the same answer: we’ll write more tests. Sometimes there are other answers thrown in there, but testing is the thing we all think we should be doing better.

The same teams have made the same resolution time and time again, so I wonder why it is that teams like this aren’t writing enough tests. “Enough tests” may be a poor choice of words — the quality of your tests is just as important as the quantity. But either way: based on my own anecdotal findings, most of us think we should be writing more / better tests.

So why don’t we? When I think about it logically, there is an obvious conclusion (obvious to someone who is fanatical about TDD). It’s hard to write tests after the fact.

You see, test driven development forces you to write code in small steps that are easily testable. I might write one test, then write another few lines, followed by another test, followed by another few lines.

But most teams who write their tests after they write their features don’t work with this incremental approach. You might write 200 lines of code before you start testing it. That leaves you with a working feature, little incentive to test it, and a lot of refactoring to do before you finish.

Why refactoring? Well, those 200 lines may not be easy to test. In order to make them testable, you’ll need to refactor a little. Refactoring can easily break your code, but at least you have a safety net of tests to… oh wait. See the problem?

So write your tests first. Not only will it give you a safety net from the start, but it will also mean one less refactor. Or more accurately, it will mean that refactor will be broken down into smaller chunks that are easier to manage.
What is TDD and Why Should You Care About It?
Test Driven Development is the act of writing your tests before you write the code you are testing. Want to write a feature that allows you to add a product to your basket? Start by writing a tests that checks if the feature works. The test will fail, because the feature hasn’t been written yet. Then you can write the feature to make the test pass. Simple, right?
How Do I Test Something I Haven’t Written Yet?
If you want to test 200 lines of code you haven’t written yet, you’ll have a tough time doing it. It’s hard enough to think about the next 200 lines when you are writing them, never mind when you are trying to figure out how to test them. The idea isn’t to write a whole feature’s worth of tests before you get started on the implementation. That would require incredible foresight to know exactly how you will implement the feature, without the benefit of any kind of feedback.

Instead, you test just enough to cause a test failure. This keeps you focused on the problem directly in front of you rather than the final destination. As always, I find examples help in this situation:

Let’s say you are writing a basket on an eCommerce website. At present adding a product doesn’t check the stock levels before adding an item to the basket. You’ve been asked to make sure products can only be added to the basket when they are in stock.

There are a whole bunch of tests you might think of at the outset. Here are some of the ones I thought of:
1. Given that Product A is in stock (quantity > 0)
  When I add Product A to my basket
  Then there should be 1 x Product A in my basket
2. Given that Product A is in stock (quantity = 0)
  When I add Product A to my basket
  Then there should be an error telling me the item is not in stock
3. Given that Product A is in stock (quantity = 1)
  When I add 2 x Product A to my basket
  Then there should be an error telling me there is not sufficient stock
Assuming that there are already tests for adding an item to your basket (without checking stock), then test 1 should be easy to write, so we should start there. Write the other test cases down and just focus on the problem in front of you, which is “how do we check stock levels?”

Your first test might only look like this:
```
it('should add an item to the basket when it is in stock', () => {
    let mockStockService = {};
    let basket = new Basket(mockStockService);
});
```
This isn’t much of a test — there aren’t even any assertions yet! But when considering how to check stock levels, I decided I would need to inject a service to do so. As soon as I try to instantiate the Basket class with this service, I get an error because the constructor does not expect any arguments. This is a failing test, even if it is only caused by a compilation failure rather than an assertion.

I don’t know exactly what methods will be on the service yet, but I can now update the Basket class to accept a StockService in its constructor. With that done, the test should “pass” (i.e. compile), at which point I can move onto my first assertion:
```
it('should add an item to the basket when it is in stock', () => {
    let mockStockService = {
        getStockLevel: jasmine.createSpy()
    };
    let basket = new Basket(mockStockService);
    basket.add(new Product(123));

    expect(mockStockService.getStockLevel).toHaveBeenCalledWith(123);
});
```
Again, I have wrote the minimum amount to make a test fail. I decided that I need a method called getStockLevel so I implemented a spy, but not a return value. I just want to get to the next assertion.

This doesn’t mean you’re only thinking about one problem at a time, but simply that the ones in sharpest focus are the ones closest to you right now. Don’t focus on a problem you don’t have to solve yet, because you will take brain power away from the ones you do. And by the time you have to solve that faraway problem, it may look a whole lot different.

This is one thing that I think people forget to explain about Test Driven Development. It’s not just about writing better tests, but it naturally breaks big problems down into bitesize pieces. As a result, testing can often feel much less daunting than it would if you had 200 lines of code to test. You’re generally just trying to find the minimum amount of test that will cause the test run to fail, followed by the minimum amount of code to make it pass.

Then you refactor, if needed. This time you have a safety net in the form of the test you just wrote. This process is often called Red, Green, Refactor.
- Red is when you have a failing test.
- Green is when the test is passing.
- Refactor is when you look at how you made the test pass and decide there is a better way. Rather than saying “we’ll fix that later” you make an effort to fix it now, while it’s fresh in your mind.
Just remember that it’s all about keeping this loop as short as possible. You ought to be switching between test / implementation every few minutes at most if you can manage it. Doing so will break down the problem you’re solving into digestible chunks that won’t give your brain heartburn.

So stop writing tests for code you’ve written and start writing tests for code you haven’t written yet.
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/