采用Elixir实践指南：团队初次使用Elixir的必备读物

需积分: 9 99 浏览量更新于2024-07-16 收藏 3.86MB PDF 举报

"Adopting Elixir_p1_0.pdf 是一本关于采用Elixir语言的实践指南，适合希望首次正确使用Elixir的团队。书中的理念与资深咨询顾问Claudio Ortolina的咨询经验完全吻合，并得到了他的高度推荐。这本书对于早期采用Elixir的团队，如David Marks所在的Bleacher Report，以及Elixir in Action的作者Saša Juric，都是必备读物，提供了从开发到部署再到生产环境的深入讨论。" 在Elixir的世界里，"Adopting Elixir"是一本非常重要的参考资料，它为那些想要引入Elixir技术的企业或团队提供了实用且无冗余的指导。Elixir是一种基于BEAM虚拟机的函数式编程语言，设计时考虑了并发性和可扩展性，尤其适合构建高可用性和高性能的分布式系统。本书的核心内容可能包括以下几个关键知识点： 1. **Elixir语言基础**：介绍Elixir的基本语法、数据类型、模式匹配、流程控制等概念，帮助读者快速上手Elixir编程。 2. ** OTP（Open Telecom Platform）**：Elixir的一大优势是其对OTP的优秀支持。书中可能会详细介绍如何利用OTP的设计模式来构建健壮、容错的应用。 3. **并发与并行处理**：Elixir通过进程模型实现并发，使得开发者能够轻松地编写出能充分利用多核CPU的程序。这部分可能会讲解如何有效地利用进程进行通信和数据共享。 4. **元编程**：Elixir的元编程能力使得代码更加灵活，可以动态生成代码。书中的这部分可能包括宏(macro)的使用和元编程的最佳实践。 5. **测试与调试**：Elixir有一套强大的测试框架，如ExUnit。书中会涵盖如何编写有效的测试用例，以及如何进行调试，确保代码质量。 6. **部署与运维**：在生产环境中，部署和运维是必不可少的环节。本书可能会提供有关如何将Elixir应用部署到不同的环境，如Docker容器或云平台，以及如何监控和维护系统的策略。 7. **团队协作与代码管理**：针对团队开发，书中的内容可能包括版本控制、代码审查、持续集成/持续部署(CI/CD)等方面的最佳实践。 8. **案例研究**：通过实际项目案例，展示如何将Elixir应用于实际业务场景，解决特定问题，以增强读者的理解。 9. **扩展与优化**：探讨如何随着项目发展进行系统扩展，以及如何优化Elixir代码以提高性能。 "Adopting Elixir"是一本全面覆盖Elixir语言采纳和应用的书籍，无论是对于新手还是有一定经验的开发者，都能从中获益，避免在实践中走弯路。

you are still deciding if Elixir is the right tool for you, you will likely get more

mileage from the first chapters and you can revisit the production discussion

once development starts.

We understand that’s not the typical experience, but we made that trade-off

because each adopting developer has a different set of needs. No simplistic

grouping of technologies can cover everything that needs to be said. We’re

willing to take our lumps in the review process because we believe in the need

for this book in the greater community.

With those bits of housekeeping done, let’s dive into the parts of the book.

We’ll also highlight which parts will be of particular interest based on your

individual use case.

Part I: Concept

Adoption is in part a social problem. Adopting an emerging technology means

becoming a salesperson. Helping stakeholders, teammates, and potential new

hires understand that our technical decisions are wise and in the best interests

of the companies we serve is a critical part of the process. New languages

often mean new hiring and team-building strategies. Adoption is changing

habits and practices to take best advantage of our new platform. This book

will give you tools to help automate those things you can and lay out experi-

ences to help you handle the things you can’t. We’ll walk you through the

discussion in three chapters:

Team Building

Building a team for an emerging language is a little different than ramping

up for a well-known, established technology. We’ll tell you what we did

to train and recruit talent, set expectations, and keep folks motivated. If

you have an established effective team and a good handle on recruiting

and training, you will probably want to skip this chapter. If you find

yourself ramping up or training for a new adoption or if you’re concerned

about finding talent, this chapter will help you in your efforts.

Ensuring Code Consistency

It’s easy to fall into old habits when you’re learning a new language, but

that would limit the benefits you’d reap. This chapter will show you how

to use automated tools to gently nudge your team toward a more beautiful

idiomatic coding style. If you have a comfortable cadence and are already

well versed with lexers like Credo, Elixir’s testing ecosystem, and Elixir’s

documentation tools, you may not give this chapter more than a quick

Introduction • xvi

report erratum • discuss

Prepared exclusively for Michael Hanna

skim, but most developers will appreciate the concepts outlined in this

chapter. You can automate many different aspects of code quality.

Legacy Systems and Dependencies

Many of the companies adopting Elixir are choosing it to replace a legacy

system, and we’ll cover that topic. Dealing with legacy systems also means

carefully considering each new line of code you write and each new

dependency you add. Sometimes code becomes legacy because of business

needs, other times because the code becomes less healthy. In this chapter

we will talk about how to replace legacy systems, building tomorrow’s

friendlier legacy systems as you write code today, and working with

internal and external dependencies.

If you’re a manager, an executive, or a team lead tasked with building a team

and establishing culture, Part I is for you. The chapters in this part will also

be of interest if you are starting your own project and need to understand

what tools can help you build consistent code.

When you’re through with Part I, you’ll understand how to build a unified

tool that writes uniform code. You’ll then think about the best ways to think

about taking that old system apart to adopt the new, should that be your

chosen path.

Part II: Development

This part will show you how others have successfully built Elixir applications

using new development teams or retooled teams who wrote in some other

language. We’ll focus on how to write code to do things beyond what you’d

find in most typical technology books. We’ll focus specifically on ideas and

tools we’ve found difficult to find elsewhere. In particular, we’ve divided this

part into the following chapters:

Making the Functional Transition

Object-oriented developers sometimes have trouble learning functional

languages. This chapter gives advice to help make that transition. It is

tailored specifically for beginning and intermediate Elixir developers,

especially those who have come from other ecosystems.

Distributed Elixir

Adopting a new language is hard enough when you’re only concerned about

one system. It takes experience to learn to split concepts across the wire.

This chapter provides exactly that. We’ll talk about how to name things,

the role of OTP, and how to think about distribution. If you’re a technical

report erratum • discuss

How To Read This Book • xvii

Prepared exclusively for Michael Hanna

lead or looking to break Elixir out of a single box, this chapter will help you

reason about the next level of challenges you’re likely to face.

Integrating with External Code

Sometimes, Elixir is not enough. When your code needs to step out of its

universe, Erlang and Elixir provide several tools to do exactly that. This

chapter covers those tools, whether you decide to stay in the same mem-

ory space, or use different processes or different machines altogether. If

you plan to stay within the Elixir ecosystem for all of your application

needs, you’ll likely want to skip this chapter. Just give it a quick skim so

you’ll know the techniques available to you should the need arise.

If you’re a new Elixir developer making the transition from OOP to FP, the

early chapters in this part will help. If you’re an experienced developer but

struggling with what it means to write a distributed project or the approaches

to integrating external code, the later chapters in this part will have something

you find useful.

When you’ve completed Part II, you’ll have more tools to think about the

things that trip up early adopters from functional programming to concur-

rency, even distributed systems. Then, in the final part, we’ll worry about

deployment.

Part III: Production

Every new language community has to work out what to do with deployment.

Elixir is no different. It’s not surprising that one of the most common questions

Plataformatec received was how to deploy, and how to monitor the system

once deployed. This part of the book will point to some prevailing wisdom in

these areas. In particular, you’ll see chapters for:

Coordinating Deployments

Deploying a simple system on a single server is a pretty easy problem,

but modern applications no longer fit that profile. This chapter will show

how successful DevOps folks think about releases and the tools they use

to deploy. In some teams, the folks that write the code are the same ones

that deploy and support it in production. If you’re involved in any way in

deploying Elixir or packaging your code for deployment, this chapter is

for you.

Metrics and Performance Expectations

Typically, new languages have some lesser-utilized areas with less docu-

mentation than others. Since performance measurements often happen

Introduction • xviii

report erratum • discuss

Prepared exclusively for Michael Hanna

after production applications are close to ready, this topic is one of the

last to develop. When it’s time to push Elixir to the limits and test perfor-

mance, you’ll need to know how to measure your performance and report

those results. This chapter will tell you what you need to know. The

techniques are advanced and the topics specialized, so you’ll want your

Elixir foundations to be pretty solid to attack this material.

Making Your App Production Ready

Once a system reaches deployment, the debugging and monitoring tools

change. That throws many developers off, but Elixir has some unique

capabilities that greatly simplify this process. This chapter will focus on

instrumenting, measuring, and monitoring production systems. Just

about all developers need to know about the debugging, logging, and

reporting techniques in this chapter.

If you’re in operations or responsible for seeing that your application is easy

to deploy and manage, this part will be invaluable to you. Leads and architects

will also want to understand how the deployment story fits together.

When you’ve finished this part, you’ll know how others deploy with confidence.

You’ll learn what to measure, how to instrument your code, and how to

monitor for the best possible reliability and information.

About the Code

The sample code and examples included in this book are written using the

Elixir programming language, and will walk you through many broadly differ-

ent Elixir concepts. Some of those are just fragments and some are full

working examples. We’ll show you how to use each example in the context of

the book.

This book is about showing you a wider picture of the evolving greater Elixir

ecosystem. Keep in mind that the nature of this book is that some of these

code examples are just snippets, or segments of a fully working system. We

can’t possibly show you whole working systems for all of the examples in this

book. Such a book would be many times the size of this one and take much

longer to write.

Instead, we will let the prose and the code work together. Let the prose guide

you through the proper use of the code examples. If you find any concepts

that are not clear, just let us know in the forums. We will help you the best

we can.

report erratum • discuss

About the Code • xix

Prepared exclusively for Michael Hanna

剩余231页未读，继续阅读

fh250250

粉丝: 0
资源: 1

采用Elixir实践指南：团队初次使用Elixir的必备读物

Elixir程序设计语言.pdf

USB_3_0_Adopters_Agreement_Final_020411.pdf

华为薪酬体系_华为人力资源管理.ppt

pthreads-w32-2-1-0-release.tar.gz

Programming-in-Scala-2nd.pdf

Ford-Trends-Book-2016-Interactive.pdf

common-sense-c-advice-and-warnings-for-c-and-c-programmers.9781882419005.32087

Microservice-Architecture-Aligning-Principles-Practices-and-Culture.pdf

藏经阁-Adopting Dataframes and Parque.pdf

MIPI_DSI_Spec官网下载.rar

最新资源