开源日报 - Page 161 of 262

开源日报第400期：《强化版本 Cello》

19 4 月, 2019
开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《强化版本 Cello》
今日推荐英文原文：《Introduction to HTTP 2》

今日推荐开源项目：《强化版本 Cello》传送门：GitHub链接
推荐理由：一个对于 C 语言进行加强的库，让 C 也能做到一些现在流行的功能——比如无处不在的构造/析构函数。虽然这玩意的确增添了许多管用的功能给 C，但是终究只是用于娱乐的项目，如果要想用于工作中的话，C++ 是一个比这玩意更好的选择。
今日推荐英文原文：《Introduction to HTTP 2》作者：
原文链接：https://medium.com/@shaved786/introduction-to-http-2-8aa8c565d008
推荐理由：对 HTTP2 的介绍——尽管还有缺点，但是目前是最优解
Introduction to HTTP 2

A Brief History Of HTTP
HTTP is an old protocol, initially defined in 1991, with the last major revision — HTTP/1.1 — published in 1999. Websites in 1999 were very different to the websites we develop today. The amount of data now required to load the home page of an average website is 1.9 MB, with over 100 individual resources required to display a page — a “resource” being anything from an image or a font to a JavaScript or CSS file. HTTP/1.1 does not perform well when retrieving the large number of resources required to display a modern website.
Brief Introduction of HTTP/2
HTTP/2 will make our applications faster, simpler, and more robust — a rare combination — by allowing us to undo many of the HTTP/1.1 workarounds previously done within our applications and address these concerns within the transport layer itself.

The primary goals for HTTP/2 are to reduce latency by enabling full request and response multiplexing, minimize protocol overhead via efficient compression of HTTP header fields, and add support for request prioritization and server push.

HTTP/2 does not modify the application semantics of HTTP in any way. All the core concepts, such as HTTP methods, status codes, URIs, and header fields, remain in place. Instead, HTTP/2 modifies how the data is formatted (framed) and transported between the client and server, both of which manage the entire process, and hides all the complexity from our applications within the new framing layer. As a result, all existing applications can be delivered without modification.
Features of HTTP/2

Binary framing layer
At the core of all performance enhancements of HTTP/2 is the new binary framing layer, which dictates how the HTTP messages are encapsulated and transferred between the client and server.

Unlike the newline delimited plaintext HTTP/1.x protocol, all HTTP/2 communication is split into smaller messages and frames, each of which is encoded in binary format.

As a result, both client and server must use the new binary encoding mechanism to understand each other: an HTTP/1.x client won’t understand an HTTP/2 only server, and vice versa. Thankfully, our applications remain blissfully unaware of all these changes, as the client and server perform all the necessary framing work on our behalf.
Streams, messages, and frames
The introduction of the new binary framing mechanism changes how the data is exchanged between the client and server. To describe this process, let’s familiarize ourselves with the HTTP/2 terminology:
- Stream: A bidirectional flow of bytes within an established connection, which may carry one or more messages.
- Message: A complete sequence of frames that map to a logical request or response message.
- Frame: The smallest unit of communication in HTTP/2, each containing a frame header, which at a minimum identifies the stream to which the frame belongs.
The relation of these terms can be summarized as follows:
- All communication is performed over a single TCP connection that can carry any number of bidirectional streams.
- Each stream has a unique identifier and optional priority information that is used to carry bidirectional messages.
- Each message is a logical HTTP message, such as a request, or response, which consists of one or more frames.
- The frame is the smallest unit of communication that carries a specific type of data — e.g., HTTP headers, message payload, and so on. Frames from different streams may be interleaved and then reassembled via the embedded stream identifier in the header of each frame.
Request and response multiplexing
With HTTP/1.x, if the client wants to make multiple parallel requests to improve performance, then multiple TCP connections must be used. This behavior is a direct consequence of the HTTP/1.x delivery model, which ensures that only one response can be delivered at a time (response queuing) per connection.

The new binary framing layer in HTTP/2 removes these limitations, and enables full request and response multiplexing, by allowing the client and server to break down an HTTP message into independent frames, interleave them, and then reassemble them on the other end.

One connection per origin
With the new binary framing mechanism in place, HTTP/2 no longer needs multiple TCP connections to multiplex streams in parallel; each stream is split into many frames, which can be interleaved and prioritized. As a result, all HTTP/2 connections are persistent, and only one connection per origin is required, which offers numerous performance benefits.
Server push
Another powerful new feature of HTTP/2 is the ability of the server to send multiple responses for a single client request. That is, in addition to the response to the original request, the server can push additional resources to the client (Figure 12–5), without the client having to request each one explicitly.

Why would we need such a mechanism in a browser? A typical web application consists of dozens of resources, all of which are discovered by the client by examining the document provided by the server. As a result, why not eliminate the extra latency and let the server push the associated resources ahead of time? The server already knows which resources the client will require; that’s server push.
Header compression
Each HTTP transfer carries a set of headers that describe the transferred resource and its properties. In HTTP/1.x, this metadata is always sent as plain text and adds anywhere from 500–800 bytes of overhead per transfer, and sometimes kilobytes more if HTTP cookies are being used. To reduce this overhead and improve performance, HTTP/2 compresses request and response header metadata using the HPACK compression format that uses two simple but powerful techniques.
1. It allows the transmitted header fields to be encoded via a static Huffman code, which reduces their individual transfer size.
2. It requires that both the client and server maintain and update an indexed list of previously seen header fields (in other words, it establishes a shared compression context), which is then used as a reference to efficiently encode previously transmitted values.
Pros and Cons

Pros :
- HTTP/2 is binary, instead of textual.
- HTTP2 enables a more efficient use of network resources and a reduced perception of latency by introducing header field compression.
- HTTP/2 is fully multiplexed. We can make multiple parallel requests to improve performance within a single TCP connection. which in turn leads to better utilization of available network capacity.
- With the new feature of server push, the server already knows which resources the client will require without the client having to request each one explicitly like CSS or JS files.
- Overall with HTTP2 we can decrease the load time of our application drastically.
Cons :
First of all, there really isn’t an alternative available today that’s superior to HTTP/2. But, as an IT pro, you should still know the protocol’s weak points. Some experts believe that these issues may be fixed in the future with the release of the “HTTP/3” protocol, but for now, these are a few of the cons.
- Encryption is not required.
- Cookie security is still an issue.
- It’s not very fast, and not super modern.
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第399期：《领导 awesome-leading-and-managing》

18 4 月, 2019
开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《领导 awesome-leading-and-managing》
今日推荐英文原文：《What is DevOps and Why Do We Need It?》

今日推荐开源项目：《领导 awesome-leading-and-managing》传送门：GitHub链接
推荐理由：干得久了经验多了，迟早有一天就会作为新手的领路人。这个项目就是一个关于领导和管理的资源集合——在你接触这些之前可能想不到这玩意会涉及那么多方面：时间管理、文化、建议……不管哪个方面都不是可以轻易无视的。没有人是天生的领袖，那些看起来像是天生领袖的人，只不过是作为领袖时比其他人更为了解这些方面，但不可否认的是，这的确很重要。
今日推荐英文原文：《What is DevOps and Why Do We Need It?》作者：Skywell Software
原文链接：https://medium.com/datadriveninvestor/what-is-devops-and-why-do-we-need-it-82c2ef0a9d3d
推荐理由：对于 DevOps 的介绍
What is DevOps and Why Do We Need It?
The DevOps methodology has been recognized by many experts as the best way to promote cooperation between development and operations teams. However, DevOps is much more than a methodology. It is more of a culture that makes both the technical and business sides of software development much more efficient thus reducing time to market and increasing the overall quality of the product. Before we get into why DevOps is important, let’s get the definition of it first.
DevOps Definition
DevOps is an offspring of the Agile methodology that breaks down the barriers separating development and operations teams thus increasing collaboration between them. However, if you do not have the right culture in place, DevOps is just a buzzword. The following are some of DevOps culture:
- Shared responsibility — In many companies, the development team is focused solely on creating the product and can become disinterest or even estranged operating and managing a system if it is somebody else’s job. If it is also part of the development team’s responsibility to monitor the system over the course of its existence, they are likely to feel the same pains operations teams are dealing with. This will lead to finding new ways of simplifying deployments and the maintenance by automating the deployments and better logging.
- Autonomous teams — Effective collaboration is only possible when development and operations teams can make decisions and changes independently without a complicated decision-making process. This includes trusting your teams, adjusting the way risks are managed and getting rid of an environment where employees are afraid of taking risks or failing.
- Removing all silos — Some companies document the process and hand this documentation over to another team and consider this to be regular cooperation. Such an arrangement is doomed from the start because it promotes a culture of finger pointing and blaming. You must adjust resourcing structures to let operations teams start collaborating with other teams early on. One of the goals of DevOps is to blur the line between development and operations team to the point where there may not be a difference between them at all.
The DevOps Lifecycle
There are many stages that make up the DevOps lifecycle, but the process will look like the following:
- Plan — This stage includes initial planning about how you envision the development process
- Code — Coding the applications according to the requirements of the customer
- Build — Integrate all of the various codes you have written
- Releases — If the testing phase was successful, the application could go live
- Deploy — The code is deployed to a cloud environment for additional usage
- Operate — Conduct the operations on the code
- Monitor — Keep an eye on how well the app is performing and make any changes necessary to satisfy the client.
Why Do We Need DevOps?
DevOps offers a lot of benefits for software programming companies such as increased innovation speed which will allow you to serve your customers better. You will also be more flexible to adjust to changing market conditions and drive higher business results. Since the speed and tempo of the releases will be frequent, you will be able to improve your product faster. This way you can release new features sooner, notice and fix bugs quicker and perhaps most importantly, respond to customer demands better to give your business a competitive advantage. Continuous integration and delivery (CI/CD) are practices that automate the software release process starting from the build and all the way to deployment.

Even though the pace of production will increase, it has to be done so reliably. You will be able to use CI/CD to test all of the changes, and better monitoring and logging will help you continuously stay on top of how well your application is doing in real-time. Security process will not be compromised since the compliance policies will be automated by using fine-grained controls and configuration management techniques.
Conclusion
If you are just embarking on your journey towards DevOps implementation, it is essential to set realistic goals expectations. While you may be eager to reap all the benefits of DevOps project management, your teams may experience culture shock, since they are used to the old siloed structure. It is not easy to change well-established processes, and it will take some time to implement on the people, process and information levels. This culture shock will usually come in the form of new goals. You cannot tell your teams, which are used to delivering one release a month, that they will need to have five releases every day from now on. This is simply not going to work.

You need to have a more structured approach with the understanding that the release schedule might slow down at first as your teams become acquainted with the DevOps culture and methodologies. This will require a lot of education, training and some time to get used to all of the changes. As the transition is going on, it is important to set and monitor business critical metrics such as overall revenue and customer satisfaction. There is no point in having multiple releases just for the sake of having various releases. It must make an impact on the bottom line.

Given all of the benefits that DevOps offers it is safe to say that companies who fail to implement DevOps process risk falling behind. One of the most common misconceptions is that DevOps is just for large companies when in fact small and medium-sized business can take advantage of everything DevOps has to offer. In fact, one of the reasons that companies such as Facebook, Netflix, and other conglomerates were able to achieve such rapid growth is because they were early adopters of DevOps and were able to deliver new features to their user faster than the competition. Therefore, if you have not yet begun implementing DevOps, you are falling behind your competitors.
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第398期：《Git 小提示 tips》

17 4 月, 2019
开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《Git 小提示 tips》
今日推荐英文原文：《A 3-step process for delivering tough feedback》

今日推荐开源项目：《Git 小提示 tips》传送门：GitHub链接
推荐理由：这个项目介绍的是使用 Git 时的一些小技巧——在你需要一些特定操作的时候它们可能会帮上你的忙。除此之外，像 git help everyday 这样并非用于工作的命令也是有点意思的，只需要简单的输入命令就会得到一个教程页面——按照不同角色定位来介绍他们常用的命令，具体的内容各位就自行探索吧。
今日推荐英文原文：《A 3-step process for delivering tough feedback》作者：Matt MacKinnon
原文链接：https://opensource.com/open-organization/19/4/be-open-with-difficult-feedback
推荐理由：如何用恰当的方式说些对于你的下属来说可能不算太好的话
A 3-step process for delivering tough feedback
Seventeen years ago, I’d earned my first leadership role and become responsible for roughly ten direct reports. Two weeks into the role, my boss took me for a coffee to chat about how things were going.

“I’m not getting what I need from you,” she said.

The statement left no ambiguity, no wiggle room, and no space for interpretation. She let it hang in the air for a moment. When I acknowledged it, she followed it up with direct examples of what she needed and what she was seeing.

I now realize it was the first proper coaching session of my career.

Too often, managers withhold tough feedback because they worry it will negatively affect an employee. The reality, however, is that failing to have tough conversations with people actually does them a disservice. People deserve to know where they stand. They deserve an opportunity to improve. They deserve a chance to address perceptions of their performance.

The alternative is avoiding the temporary stress (mostly yours) and letting someone float through their career unaware of the things that could be holding them back. Those things will eventually catch up to them through missed opportunities, stagnant salary, or feedback that seems unexpected or unfair.

In open organizations, the kind of honest, clear, and direct feedback my manager once gave me should be the norm. If people in these organizations can hope to maintain a high degree of adaptability, they need this kind of feedback.

But delivering it can be a frightening prospect for any manager. So how do you get started?

I’ll share a simple approach that has worked well for me. It consists of three easy-to-remember steps:
- Prepare
- Stay on message
- Follow through
1. Prepare
Remember that a coaching session is an investment in helping your people succeed and grow. Spending a bit of time preparing your feedback helps you clarify the message you want to deliver, keep the meeting on track, and (hopefully) lower your stress levels.

As you prepare, keep these priorities in mind:
- Focus on a specific behavior
- Provide recent and concrete examples
- Show how the behavior is causing unwanted outcomes
- Outline your expectations
If you don’t have recent examples, then perhaps you’ve been putting this conversation off for too long. In that case, I’d advise you not to have it. Failing to address something that occurred three months ago was your stumble, not someone else’s. If the behavior continues to be an issue in the future, then you’ll have another chance to address it when the matter is fresh.

Too often, managers withhold tough feedback because they worry it will negatively affect an employee. The reality, however, is that failing to have tough conversations with people actually does them a disservice.

If you’re new to delivering feedback, take some time to rehearse how the conversation might go. You can do it in front of a mirror, in the car, while walking the dog, silently in your head—whatever technique works for you. But get comfortable with the content. Don’t let your remarks appear scripted, but get to a point where you don’t need to read from your notes to hit key points.

Now it’s time to have the meeting. Reach out, let the person know you’d like to talk, and meet with them immediately. Try to avoid scheduling a meeting that seems out of the blue or centers on a vague topic; that’ll create extra stress for both of you.

Now that the meeting has started, stay on message.
2. Stay on message
Naturally, you’ll find delivering tough feedback to be intimidating. Most employees are surprised to find out they are not meeting expectations, so you can expect some initial tension, disappointment, and letdown. In the midst of the tension—and while watching someone struggling—your gut reaction will likely be to console them.

Don’t.

They need to feel the impact of your feedback. The biggest mistake you can make at this point is going off message by watering down the seriousness of the issue or throwing in some positive feedback to make you both feel better. Doing this only confuses the message and will likely delay someone’s progress in addressing it. Instead of going off message, let the silences linger a little if you need. It may feel awkward, but you’ll both survive.

Remember the outcome you desire from this conversation: A clear understanding, agreement on the issue, and acknowledgment that your report is responsible for addressing it. Remember, too, that the conversation is not a debate. During that initial tension, your report may go on the offensive and attempt to either counter your feedback or explain it away. You know its a real issue, so be firm and shut down debate.

Keep the meeting short—just enough time to clearly communicate the message, work through the examples, and reiterate expectations. Sometimes, your report will be immediately accepting and want to dive into solutions for addressing shortcomings. If you can make the meeting a productive working session, then go for it. But more often you’ll need to allow the person some time to truly digest what you’ve said. You’ll be following up (see below), so don’t worry. You can spend more time helping them along.

Finish with a commitment—from both of you—to work on and support the changes. Then let your report know you’ll be following up with an email for their reference.
3. Follow through
You survived! Good news: the hardest part is probably over. The next time you face the situation it should be easier. But the work is really just beginning.

I think of this last phase of work, following up, in three phases:
- Immediate
- Short-term
- Long-term
Immediate
Immediately—as in, when you get back to your desk—summarize the key points in an email and send it to the person. If need be, you can draft this note in advance of the meeting and modify it based on your actual conversation. Keep it short and direct. Use bullet points. Incorporate phrases like “as we discussed” to make clear that you had the conversation together. Reiterate their acknowledgment of the issue. End with a statement about your intention to support them.
Remember the outcome you desire from this conversation: A clear understanding, agreement on the issue, and acknowledgment that your report is responsible for addressing it.
Then send it only to them. Copying other people that were not in the conversation will unnecessarily heighten its severity. Forward it to your manager or HR department separately if you believe they need to know about the conversation. This gives you both a record of the conversation, something to refer back to in the future as you work together on the behavior in question. It also serves as “evidence” of the coaching if you need to take more serious action down the road. Make this a habit throughout your coaching, for both positive and challenging feedback.
Short-term
Make a point to check in with this person the next day and reaffirm your compassion: “I know it was tough feedback. How are you feeling?” This conversation should not be as tense as your previous one since the surprise and defensiveness should be gone. Checking in goes a long way to building the trust necessary for continuing to coaching them. Just remember that it’s still not a coddling session.

Now is the time to really demonstrate your commitment to coaching. Watch for similar situations to arise and observe how the person responds to them. More than ever, you need to be timely with your feedback so that you reinforce the positive behavior and identify specific instances where they’re not meeting expectations.

The advice above is short and straightforward—but it is continuous and will occur over several weeks. So be diligent and stay the course. Remember: you’re committed to helping, and you have the person’s attention. Now is the time to capitalize on the investment you’ve made.
Long-term
When you observe your report demonstrating desirable behavior consistently, there isn’t much left to do. Just watch for slips and provide feedback quickly to prevent a return to former habits.

Why is there no middle term? The timeline improving the behavior needs to be tangible. Don’t draw it out over months. If you’ve provided the coaching, offered a clear message, and provided examples, then you should expect to see the improvement fairly quickly or be prepared to take stronger action.

Experience has taught me that most people will rise to meet expectations if given the chance. And for the few who don’t, there should be no surprises down the road.

As for me: I did my part and acted on my manager’s feedback, reflecting on the examples and changing my approach. Then, after another couple of weeks, she took me for another coffee. This time, she led with a smile and said: “Keep doing what you’re doing.”

That 10 minutes of coaching impacted my career and my understanding of open leadership. I like to think I would have figured it out on my own, but it would have been a lot harder.

Do you owe anyone a cup of coffee and an open conversation?
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/
开源日报第397期：《护眼模式 GitHub-Dark》

16 4 月, 2019

开源日报每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文，坚持阅读《开源日报》，保持每日学习的好习惯。
今日推荐开源项目：《护眼模式 GitHub-Dark》
今日推荐英文原文：《A Complete Guide to Python Web Frameworks》

今日推荐开源项目：《护眼模式 GitHub-Dark》传送门：GitHub链接
推荐理由：用过各种读书 app 的朋友兴许都知道这世界上有个叫做护眼模式的东西——如果你能在周围一片漆黑的时候打开它，看起来会很舒服。这个项目就是 GitHub 的护眼模式，如果你经常需要在一片漆黑下对着你的电脑的话，兴许可以尝试使用它——Your eyes will ❤️ you.
今日推荐英文原文：《A Complete Guide to Python Web Frameworks》作者：Premjith B P K
原文链接：https://opensourceforu.com/2019/04/a-complete-guide-to-python-web-frameworks/
推荐理由：关于 Python 中流行 web 框架的介绍
A Complete Guide to Python Web Frameworks
Web frameworks are code libraries that make Web development faster and easier. The versatile programming language, Python, has many Web frameworks like Django, Web2py, Flask, Bottle, etc. We take a closer look at these in this article.

Python is a valuable and flexible programming language designed specifically for teams trying to get a Web application up and running. Developers and frameworks are closely related since they are the building blocks of the products being crafted. With such frameworks, a set of solutions is born, thereby allowing the developer to focus more on the app logic rather than repetitive and other low-priority tasks.

Nowadays, developers try Python’s robust collection of frameworks to deal with the details of the implementation, which helps to hasten the development and prototyping process. There are various well known Python Web frameworks out there – from vigorous full-stack frameworks specifically designed for enterprise based solutions to ultra-lightweight micro-frameworks streamlined for developing small and specialised tools.

Python Web frameworks help in greatly cutting down the cost, the effort and the time spent on Web app development. We will share some key functionalities of these intriguing frameworks to help you during Web application development. In this article we aim to help you settle on the best framework, based on your needs.
What are Web frameworks?
Web frameworks enable developers to create Web applications and services without getting into the details like sockets, protocols, thread management, etc. Some of the common duties of a Web framework are to handle cookies, get form parameters, deal with sessions, etc. There are two main types of frameworks available – the full-stack and the micro-framework.
Full-stack or micro-framework?
You should be extremely focused while picking a framework, and the key things to consider should be the size and sophistication of the project. In case you’re hoping to get a function-oriented Web application that will collaborate with the rest of your association’s frameworks, then a full-stack alternative could help your team both in terms of time and effort. However, if you’re working on a small and relatively simple project with minimal requirements, a micro-framework is your best bet. A related question is: how much effort will you require from the framework? A full-stack Web framework should have all the components you require to develop a fully functional Web app – frame generators, access lists, templating, etc – so your team can assemble the page or app as per requirements. This is an alluring option for teams that are attempting to build a product quickly, since it enables them to focus only on the development of the app and not everything else that revolves around it. In any case, if you have sophisticated custom requirements or are already working with different types of custom software, you can’t exploit those libraries.
Full-stack frameworks
There are a whole new set of full-stack options available among Python frameworks. Some of the prominent frameworks are TurboGears 2, Pylons, and Web2py. But the most popular one among them is Django.

Django: This is the most well-known Python framework and anyone can easily justify the reason behind it. A huge number of websites already use Django, from publishing houses to social media and sharing sites to significant establishments and non-profits. Since Django was initially developed for use in the newsroom, it’s not a big deal that dailies like the Washington Post and The Guardian work on this framework. New companies and startups like Eventbrite and Disqus have migrated to Django to improve conversion rates, while social media giants like Instagram and Pinterest have used it to control their dynamic Web apps.

When considered as a framework, Django is known for being quick to build and friendly for amateur developers. It’s a ‘batteries included’ framework, which means it supplies all the basic components you require such as authentication, rendering template, ORM, routing, etc. It’s also well documented, which isn’t the case with some other mainstream Web frameworks.

Django can considerably reduce the time taken to bootstrap a new project by dealing with a lot of choices. However, what you gain in speed can be lost in long-term flexibility. For instance, the inbuilt ORM of Django works efficiently in major scenarios. However, it’s not as ground breaking as SQLAlchemy, which is also termed the best Python database abstraction tool. While you can hypothetically use SQLAlchemy with Django, you’ll lose out on some major functionalities that make Django so appealing to start with.

Web2py: This is another prominent full-stack framework. One thing to remember about Web2py is that it isn’t compatible with Python 3. The original developers behind Web2py have guaranteed a compatible successor for Python 3, but haven’t launched it till now.

Even though it is ten years behind the most recent version of Python, Web2py is still used by many major enterprises, including multinational banks. What makes this older Web framework still engaging for developers is its unique functionalities. For one, it’s as simple and easy to learn as Django, and is more flexible and portable too. The same code can be employed for almost any VPS with a SQL database or MongoDB, regardless of whether AWS or Google App Engine are used.

Web2py has got intense support — it is well-documented and has a strong community behind it. Another perfect element is that Web2py is accompanied by its very own IDE that incorporates a code editor, debugger, bug ticketing framework, a single tick deployment, etc. If your organisation is focused on Python 2 for the coming years or you intend to make use of some more established Python libraries and software, then Web2py could perfectly suit your requirements.

Pyramid: Pyramid isn’t exactly a full-stack framework but bills itself as the Goldilocks framework. Pyramid is enriched with features without forcing any particular way of getting things done on users. It is lightweight without leaving you all alone as your app develops. It’s one of the most loved Web frameworks among experienced Python developers on account of its transparency and modularity, and has been used by both moderately sized teams as well as tech giants like Mozilla, Yelp, SurveyMonkey and Dropbox.

In reality, almost every component of a Pyramid framework can be swapped out. You can pick how you interface with a database, or even what type (or types) of databases you want to connect with. It doesn’t authorise certain choices for you like Django does, and it also discourages some ‘magic’ features which handle certain assignments automatically. It also doesn’t behave in an anticipated or attractive way.

Pyramid is popular because of its security solutions, which make it simple to set up and to check access control records. Another innovative functionality worth mentioning is Pyramid’s Traversal system for mapping URLs to code, which eventually makes it easy to build RESTful APIs.
Micro-frameworks
Consider the possibility that you don’t need handholding or the sophistication of a full-stack framework. Nowadays, modern Web apps require lots of moving parts, including database abstraction, frame approval and modified access control records. But there are a lot of Web applications that don’t require any of it. For such projects, a micro-framework might be exactly what’s required.

These ultra-lightweight frameworks are developed to get dead Web apps up and running as fast as possible. Their capabilities are minimal by design– any functionality you could get by installing another library is intentionally left out. An advantage of working with this moderate approach is that your code can be cleaner and the site quicker. This is because micro-frameworks are less abstracted than full-stack structures. The code you compose will be significantly closer to HTTP capacities than with a more beginner-friendly framework.

Flask: Flask is undoubtedly the most famous micro-framework for Python and a standout amongst the most well-known Python structures, period. Like Django, it was developed to get Web applications up and running as fast and effortlessly as possible. Regardless of its tiny size, Flask has been used by huge organisations, including LinkedIn and Pinterest.

In any case, here’s the twist – since Flask is ideal for smaller, easier projects than Django, you can expect Web server development, support for Google App Engine and inbuilt unit testing. There is no database abstraction layer, form verification and validation, and auto upload features are disabled. However, every one of these features can be included via extensions. Some key setups incorporate SQLAlchemy for the database or Jinja2 for templating and CouchDB.

Some Python designers opt for Flask rather than Django on the grounds that the former is increasingly pythonic, in that, it generally adheres to the Python mantra of there being one approach to accomplish something, and that code ought to be clear about what it’s doing. In case you prefer clean code from scratch, Flask might be a decent alternative.

Bottle: Bottle is another prominent micro-framework. It was initially developed for building Web APIs, which is still an excellent use case for it. What is more intriguing about Bottle is that it tries to execute everything in one single document, which should give you a brief idea of how micro it is designed to be.

The out-of-the-box functionalities include templating, routing, utilities, and some fundamental abstraction over the WSGI standard. Like Flask, you’ll be coding significantly nearer to the metal than with a full-stack system. Regardless of that, Bottle has been employed by Netflix to create Web interfaces.
Other popular frameworks
We’ve gone through some of the most widely used Python systems, yet there are a variety of options you could choose from. We’ll quickly take a look at a couple of others which could perform well in particular circumstances.

Tornado is a Python Web framework particularly developed to tackle the C10k issue (i.e., it can deal with over 10,000 simultaneous connections if properly configured) using asynchronous I/O. This gives it solid appeal for projects that require elite and countless concurrent users.

CubicWeb is an intriguing Web framework that is entirely different from the other frameworks. It’s a piece of the semantic Web. In a layman’s terms, it’s a system that strives to display information in a way that is less demanding for PCs to get it. It replaces the model and view portion of MVC with a solitary concept – the data cube which can be used to develop different components, similar to Docker for the Web.

Phalcon is a micro-framework that is tied in with building cloud APIs. Like other micro-frameworks, it keeps minimal dependencies and maintains a strategic distance from complex features. However, unlike other systems, it wasn’t developed for serving HTML pages. Rather, it’s for building RESTful APIs quickly.

Even though Android has a remarkable SDK out-of-the-box, the implementation of Python instead of Java is a huge advantage for website and app development (using Kivy) since it offers quicker turnaround times and the reuse of Python libraries.

Python is a reliable and secure development language that is used for secure and agile Web app development. It is a standout amongst the available options, being the most dependable. It will reduce the development time spent trying to create a top-notch and robust Web app and site. You can consult with an experienced Python developer for your next project, for better guidance.
下载开源日报APP：https://opensourcedaily.org/2579/
加入我们：https://opensourcedaily.org/about/join/
关注我们：https://opensourcedaily.org/about/love/