Scala编程入门：问题解决与程序设计基础（第二版）

Scala

需积分: 10 188 浏览量更新于2024-07-19 收藏 14.56MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

"Introduction to Programming and Problem-Solving Using Scala, Second Edition" 是一本由Mark C. Lewis和Lisa L. Lacher合著的Scala编程入门教材，适用于初学者。本书旨在教授如何使用Scala语言进行编程和问题解决，内容简洁而详实。在书中，作者首先介绍了计算机、计算和编程的基础知识。这部分内容涵盖了计算机的历史，硬件组成部分，如中央处理器（CPU）、内存以及输入/输出设备。此外，书中还讨论了软件在计算机系统中的角色。接着，作者深入到编程的本质，讨论了编程的不同范式。这包括： 1. **命令式编程**：这是最常见的编程方式，它侧重于描述如何改变程序状态，如变量的赋值和控制流。 2. **函数式编程**：这种范式强调将计算视为函数的组合，避免可变状态和副作用，使得代码更易于理解和测试。 3. **面向对象编程**：它基于对象，强调数据和操作数据的方法封装在一起，以模拟现实世界中的实体。 4. **逻辑编程**：这种编程风格主要使用逻辑表达式来描述问题，由系统找出满足这些逻辑的解决方案。然后，作者特别提到了Scala语言，它融合了上述多种编程范式，尤其是函数式和面向对象编程。Scala的这一特性使得它成为学习现代编程理念的理想选择。书中的每个章节末尾通常会包含一些练习题，帮助读者巩固所学知识。通过阅读这本书，读者不仅可以掌握Scala语言的基本语法，还能理解如何利用Scala来解决问题，并熟悉各种编程范式的应用。 "Introduction to Programming and Problem-Solving Using Scala, Second Edition" 是一本全面的Scala入门教程，对于想要进入Scala编程世界或希望通过Scala深化编程理解的人来说，是一本宝贵的参考资料。读者可以通过访问CRC Press和Taylor & Francis Group的网站获取更多相关信息和支持。

资源详情

资源推荐

Preface

Welcome to “Introduction to Programming and Problem Solving Using Scala”. This book

is intended to be used in ﬁrst semester college classrooms to teach students beginning

programming. To accomplish this task, the Scala

programming language is used. The book

was constructed with a focus on the topics students need to know. These topics were then

woven into a format that was deemed the best way to communicate those ideas. Because

there are two very diﬀerent audiences who might be reading this, the rest of the preface is

split into two sections.

To the Student

Welcome to the world of programming. You are about to embark on a ﬁeld of study

that will hopefully open your mind to new ways of thinking and impact the way you view

everything in the world around you. For students who intend to major in Computer Science

and make careers working with computer technology, this is your ﬁrst step in learning how

to communicate with the computer and to instruct the computer in how it should solve

problems for you.

For those who are not planning to make a career in a computing ﬁeld, a course in

computer programming can still be remarkably beneﬁcial. Computer programming is, fun-

damentally, about problem solving. It is about ﬁguring out how to solve problems and

express them in ways that the computer can understand. Your entire future life is, in one

way or another, going to deal with how to solve problems. You will need to have approaches

to solving these problems well formed in your own head and be able to communicate them

to other people in non-ambiguous ways so that they understand what you want and can act

on it. Learning to program computers will help you develop and hone this ability.

There are more direct beneﬁts as well. The world you live in is already extremely depen-

dent on computing. Many of the things you own that you do not call a computer include

microchips and digital processing. Those devices/objects run programs to complete their

tasks. Many of the tasks you do during an average day are also enabled by computer power

and the ability to process and store information quickly. Activities like browsing the web for

work or leisure explicitly involve this. Other activities such as ﬁnancial transactions made

with anything other than cash implicitly involve it. This ubiquitous presence of digital pro-

cessing is only going to grow over time. So even if you never have to directly write programs

as part of your future life, you can only beneﬁt from having an understanding of what is

going on under the hood. Even if you do not write the software yourself, there is a good

chance that you will interact with those who do, perhaps as you or your company strives to

gain a competitive advantage by improving the information technology you use to do your

Code samples in this book were compiled and tested using Scala 2.12.x.

work. Even a basic knowledge of programming will help you understand what these people

are doing and communicate more eﬀectively with them.

Those who do not intend to make programming into a career might occasionally come

across problems where they realize that they could save a lot of time if they could get a

computer to do it for them. When that happens, even a basic knowledge of programming

can make your life a whole lot better. Data is becoming a bigger and bigger part of the

business world. The vast amounts of data created and collected by modern technology can

not be processed by humans manually. To sift through this data to ﬁnd meaning requires

using machines, and that means using software. You can either pay someone else to write

it or you can write it yourself. That latter is only an option if you know how to program.

While many might be tempted to view programming as an advanced concept, the reality

is this book is going to take you back to your early education quite a few times. The reason

for this is you spent a lot of time in those early years learning how to solve certain basic

problems. The approaches became second nature to you and you no longer think about

them, you just do them. In the context of programming you have to go back and examine

how you solve problems, even ones you have been doing for a long time. The reason for this

is that now you have to tell a computer how to do those same things, and the computer

will need detailed instructions. The reality is, the programming presented in this book is

not an advanced topic, it is basic logic and problem solving, done at a level you probably

have not worked at since you were much younger.

We often refer to programming as an art. Programming shares many features with

traditional arts like creative writing and painting or sculpture. The programmer ﬁrst creates

an image in his/her mind of what he/she wants to bring into existence. This is followed

by a period of work bringing that mental image into a more real form. The end result

is something new, born from the imagination of the creator, that can be experienced by

others.

The digital medium might, in some sense, seem less real than paint, clay, or stone,

but it is also remarkably dynamic. You can create things in a computer that you have no

chance of creating in the real world by hand. You can also create things that are remarkably

useful. All the software you interact with every day, whether to get things done or just for

entertainment, was written by programmers. The exercises and projects in this book have

been created with the goal of giving you the ability to express your creativity.

Programming has another characteristic in common with other creative arts, if you want

to be good at it, you need to practice. There are many ways to program the solution to any

problem. That introduces a lot of nuance. This book will strive to instruct you in regards

to the strengths and weaknesses of diﬀerent approaches, but to really understand how to

write good code to solve a problem, you need to have the experience of solving similar ones.

Imagine an art major who never draws or paints except for class projects, not even doodling

in notes, or a creative writing major who never writes a story except the ones required for

class. Hopefully those hypothetical people seem silly to you. A computer science major who

never writes code beyond what is assigned for class is exactly the same. So explore the art

of programming. Have fun with it and try to do something that interests you.

Some people might wonder why they should be using Scala to learn programming. Scala

is a fairly new language that has gained a lot of momentum since it was adopted by Twit-

ter in 2009, but there are deﬁnitely other languages that are used more for professional

development. Scala is newer than languages like Java and Python, and this means that

it has integrated lessons learned from those languages. It has more modern features that

those languages are struggling to integrate. In particular, Scala has found signiﬁcant use

in developing web sites that have lots of users and doing big data analysis. However, the

We particularly like the tag line of @muddlymon on Twitter during the time we were writing this book,

which read “I make things out of ideas by wiggling my ﬁngers.”

real reasons for starting in Scala stem from the advantages it brings to beginning program-

mers. Scala has tools like Python and other scripting languages that make it easy to write

small programs and to get started without dealing with too much overhead. Unlike Python

and other scripting languages, it does robust error checking to help you ﬁgure out when

you mess things up. Also, Scala has strong support for object-oriented programming and

functional programming, so it is able to keep growing with you beyond your ﬁrst course

in programming. You can branch out to more advanced topics without having to learn a

diﬀerent language. In addition, Scala is powerful and expressive, so that you can do a lot of

things easily. We consider this to be a signiﬁcant beneﬁt for the novice programmer as you

want to write things that are interesting sooner rather than later.

Using this Book

The goal of this book is to help you in your eﬀorts to learn how to program. In addition

to the practice that was just mentioned, there are some suggestions for how to get the

most out of this book. Clearly, working as many exercises and projects as you can counts

as practice. In addition, you should really read descriptions in this book and make sure

you understand the code samples shown in it. All too often, students treat the task of

reading course material as sounding out all the words in your head. While that ﬁts the

denotative deﬁnition, the connotation is that you string the words together and understand

what they mean. Read for understanding, not just so you can say you have gotten through

a chapter. You should also “follow along” with the material by writing code. The best way

to internalize the details of a language, and you are learning a new language, is to type

things in, so that you have to pay attention to the details. Gaining understanding of early

material is especially important in this topic because the material in any given chapter is

typically highly dependent on the chapters before it. If you fail to understand one chapter,

you are not likely to understand the ones that follow it either. As such, eﬀort spent on the

early chapters will pay oﬀ later on. Fortunately, there are resources that accompany this

book that can help with this.

Students coming into this course who have a background in programming should consider

taking a “fast path” to chapters 5 and 6. You do not want to skip them completely as there

are aspects of Scala that will likely diﬀer from what you have done before. One way to

approach this is the go to the end of any given chapter and try to do the exercises. Refer

back to the chapter as needed to complete them. Once you can do the exercises and a

project or two, you should feel comfortable moving on.

Book Website

The authors have posted a number of diﬀerent supplements to this book at http:

//book.programmingusingscala.net that can help you work through the material. Some

of the material is code or prose that could not be put into the book due to length restrictions.

The most useful things on the website are things that cannot be represented in static text.

In addition, the code samples for the book have been posted at https://github.com/

MarkCLewis/ProblemSolvingUsingScala.

There are video lectures posted on a YouTube channel (https://www.youtube.com/

channel/UCEvjiWkK2BoIH819T-buioQ) that follow along with the material in this book.

They are organized in playlists by chapter. Programming is a very non-linear process. This

book typically shows completed pieces of code that do what we want. It is hard to demon-

strate the process of building that code in the format of a book. The videos show construction

of code from the ground up and include descriptions of the programmers thoughts as it is

being done. This type of “live coding” is invaluable in learning to program as it lets you

into the mind of a more experienced programmer where you can see the thought processes

associated with the development of the code.

The web site also includes solutions of some exercises for you to reference along with

sample implementations of certain projects. Some of the projects, especially in the second

half of the book, can be challenging to describe in text. To give you a better idea of what is

expected, the author has implemented sample solutions that you can run to see what they

do. The site also includes some additional exercises and links to data ﬁles and remote sites

that make the exercises more relevant.

To the Instructor

If you are reading this, it likely means that you are already aware of many of the features

of Scala that make it a great programming language.

The ﬂexibility of Scala means that

things can be covered in many diﬀerent ways. The approach taken in this book might be

summarized as semi-functional/semi-imperative with objects later. It is worth describing

exactly what is meant by that.

This book takes advantage of the aspects of Scala that support programming in the

small. It is expected that students will operate mainly in the REPL and in a scripting

environment through at least the ﬁrst 10 chapters and possibly through the ﬁrst 15. The

beneﬁt of this is that you can focus on logic instead of extra keywords and scoping rules.

Students are easily overwhelmed early on and this approach helps to ﬂatten the learning

curve a bit.

Scala is purely object-oriented, so students will be using objects and calling methods

on objects very early on. However, the construction of classes to build their own objects is

postponed until later.

Fitting with this approach, programs are written as scripts, not as

applications, until the last chapter. So the object keyword and things like def main(args:

Array[String]) : Unit are postponed until students are ready to write programs that are

big enough that they need the organization provided by doing proper OO across multiple

ﬁles.

The approach is described as semi-functional because there is signiﬁcant use of higher

order functions with function literals/lambda expressions and immutable style is often pre-

ferred. However, this is not enforced in a zealotous way, and mutable state is introduced

early on. Students are shown mutable and immutable approaches to a number of problems

and the beneﬁts and pitfalls of each approach are discussed.

While the ideal way to go through this book is in a linear fashion, particularly if you

want to use the end-of-chapter projects as assignments, strict linearity is not required and

you can choose to move some topics around so that concepts like class declarations are

covered earlier. Though it would be a bit more challenging, it would be possible to use this

book in a more purely functional manner by simply having students avoid var declarations,

assignments into mutable collections like arrays, and the use of while loops.

If you are currently unconvinced of the beneﬁts of Scala for teaching CS1 and CS2, there is a complete

discussion at http://book.programmingusingscala.net.

That material is covered very brieﬂy at the end of this volume, but most of the treatment for doing

real OO is postponed to the second volume “Object-orientation, Abstraction, and Data Structure Using

Scala”[1].

FIGURE 1: This ﬁgure shows the dependencies between diﬀerent chapters in the book so

that you can plan what you want to cover or to allow you to intelligently choose alternate

paths through the book. Arrows point toward later chapters that use material from an

earlier chapter.

Using this Book

This book is intended to cover CS1. When looking at the chapter list, you might feel

that chapters 11 and 12 are outliers in certain ways. They deﬁnitely break from the straight

algorithmic, problem solving nature of the other chapters. This break was placed at this

point in the book at the request of students who often ﬁnd visual interfaces more compelling

than text based ones. Thanks to the syntax of Scala, it is possible to build GUIs without

explicitly declaring classes or using keywords associated with it, such as extends. It is

possible to skip these, but not advised as graphics play a role in many of the examples later

in the book.

If you have a desire to cover full OO concepts earlier, chapter 16 can be moved to closely

follow chapter 10. There are also a number of chapters through the book that contain

material that can be skipped completely. For example, chapter 14 covers XML. Scala makes

this fairly easy to do and it ﬁts in well with the projects that are given to have students

work on data stored in a formatted manner. However, if you do not want to spend time

on that topic it can be skipped with little impact on later content other than projects and

occasional usage in later chapters.

To help you decide what you can and cannot skip, ﬁgure 1 shows rough dependencies

for diﬀerent chapters in the book. Arrows point from one chapter to later ones that have

direct dependencies. There will be occasional references to material that is not in the line

of the dependency arrows, but the material should still be understandable.

The course web site, http://book.programmingusingscala.net, includes a number of

diﬀerent types of material that can be helpful for instructors. There are solutions to certain

exercises so you should check there before using exercises for grading purposes. Additional

exercises with recent links and data sets are also available on the web.

1 : Basics

Computers

17:

wrapping Up

2 : Scala Basics

•

3 : Conditionals

: Object-Orientalion

.I-~

5 : Recursion

for

lteralion

14:XML

7 : Types and Argument Passing

•

Loops

: Graphi

•

Text

Files

------·

...

10:

case

Classes

-------

...

11:

GUIS

剩余566页未读，继续阅读

leechenqi

粉丝: 2
资源: 24

Scala编程入门：问题解决与程序设计基础（第二版）

Algorithm-Problem-Solving-with-Algorithms-and-Data-Structures-using-Python.zip

problem-solving-with-algorithms-and-data-structure-using-python 中文版

leetcode卡-Competitive-Programming-and-Problem-Solving-for-Interviews:在此

Matlab A Practical Introduction to Programming and Problem Solving 3rd.Edition

Java-Programming-Problem-Solving:Java 编程和问题解决

MATLAB-A Practical Introduction to Programming and Problem Solving

Matlab a Practical Introduction to Programming and Problem Solving

matlab a pratical introduction to programming and problem solving.pdf

Matlab.. A Practical Introduction to Programming and Problem Solving

java1.5源码-Java-Programming-with-problem-Solving-in-Duke-University:关于本课

problem-solving-with-algorithms-and-data-structures-using-python

Creative-Problem-Solving-Using-VBA

Matlab A Practical Introduction to Programming and Problem Solving 4th epub 0分

Matlab A Practical Introduction to Programming and Problem Solving 4th pdf 0分

Problem-Solving-using-Bipartite-Graph

Stormy Attaway - Matlab_ A Practical Introduction to Programming and Problem Solving (2022, Butterworth-Heinemann) - libgen.li.pdf

problem-solving-using-python:使用python解决问题

Use Guide to Lean Sigma Problem-Solving

最新资源