***What are the most promising areas in CS? Why?***




I don’t have to discuss machine learning/data mining, since other answers have already done that. So I’ll put in my vote for security and privacy, even though I do not work in that area.

We rely on computers more than ever, and our reliance on them is only increasing. When you think about how many computers control systems on which we stake our lives, and what the consequences would be of these computers being hacked, it’s pretty scary.

So forget about the Facebook, Target, and Ashley Madison breaches. They didn’t kill people.

What if someone could take down the power grid?

What if someone could take over the control systems in your car? (It’s been done by getting in via a vulnerability in a telematics system.)

What if you had a pacemaker and someone could hack into it?

Security is a cat-and-mouse game, and it will continue to be one for as long as I can see. The bad guys find and exploit a vulnerability. The good guys patch it up. The bad guys find and exploit some other vulnerability. The good guys patch it up. And the beat goes on.

How much fun will the bad guys have when we have nanobots coursing throughout our blood vessels to keep us healthy?

I always recommend to my students that if they’re looking for an area of computer science for which there will always be a need, then look into security.


:::info{title="中文翻译"}
计算机科学中最有前途的领域是什么？为什么？

我不必讨论机器学习/数据挖掘，因为其他回答已经涉及到这一点。因此，我会为安全性和隐私投上我的一票，尽管我自己并不在这个领域工作。

我们对计算机的依赖比以往任何时候都更多，而我们对它们的依赖只会增加。当你考虑到有多少计算机控制我们赖以生存的系统，以及这些计算机被黑客攻击的后果会是什么时，情况变得相当可怕。

所以，别再谈论Facebook、Target和Ashley Madison的泄漏事件了。它们没有导致人员伤亡。

如果有人能够关闭电网会怎样？

如果有人能够接管你车辆的控制系统呢？（通过利用远程信息系统中的漏洞，这已经发生过。）

如果你植入了心脏起搏器，有人能够入侵它吗？

安全性是一场猫鼠游戏，而且在我能看到的未来它将继续存在。坏人发现并利用漏洞。好人加固防线。坏人找到并利用其他漏洞。好人再次加固防线。这个节奏持续下去。

当我们体内有纳米机器人在血管中流动以保持健康时，坏人会玩得有多开心呢？

我总是建议我的学生，如果他们正在寻找一个计算机科学领域，将始终存在需求，那就深入研究安全性。
:::

- **Computer Science Students:** 计算机科学学生，指学习计算机科学的个体。
- **Parallel and Distributed Computing:** 并行和分布式计算，涉及同时处理多个任务和多台计算机共同完成任务的概念。
- **Large Websites:** 大型网站，规模庞大的互联网网站。
- **Distributed Systems:** 分布式系统，由多个相互连接的计算机组成的系统，实现协同工作。
- **Prevent Failures:** 防止故障，采取措施以防止系统或组件发生故障。
- **Multiple Site Instances:** 多个站点实例，一个系统的多个相同副本或实例。
- **Virtual Machines (VM):** 虚拟机，软件模拟的计算机系统，可以在物理计算机上运行多个操作系统。
- **Parallel Systems:** 并行系统，处理多个任务或操作的系统。
- **Laptop:** 笔记本电脑，便携式个人计算机。
- **Power Outage:** 断电，电源中断，停止电力供应。
- **Built-in Uninterruptible Power Supply (UPS):** 内置的不间断电源（UPS），在电源中断时提供短时电力供应的设备，以防止数据丢失或硬件损坏。
- **Toy:** 玩具，在此处指简单或基础的系统或项目。
- **Promising Areas:** 有前途的领域，具有潜在发展前景的领域。
- **Machine Learning/Data Mining:** 机器学习/数据挖掘，是计算机科学中的子领域，用于从数据中学习和提取信息。
- **Security and Privacy:** 安全性和隐私，涉及保护计算机系统和数据免受未经授权访问和损害的领域。
- **Reliance on Computers:** 对计算机的依赖，指人们在日常生活和工作中越来越依赖计算机技术。
- **Hacked:** 被黑客攻击，指计算机系统或网络遭受未经授权的访问和操纵。
- **Power Grid:** 电力网络，用于分发电力的系统。
- **Control Systems:** 控制系统，用于监控和管理设备和流程的计算机系统。
- **Telematics System:** 远程信息系统，指用于收集和传输车辆数据的系统。
- **Pacemaker:** 心脏起搏器，用于调节心脏跳动的医疗设备。
- **Cat-and-Mouse Game:** 猫鼠游戏，指不断的竞争和反应，一方寻找漏洞，另一方修复漏洞。
- **Nanobots:** 纳米机器人，极小的机器人，可以在微观尺度内执行任务。
- **Always in Need:** 始终需要，指在未来将持续存在需求的领域。

英语翻译

***Why do computer science students need to gain knowledge about parallel and distributed computing?***



All large web sites are at a minimum, distributed systems, to prevent failures.

All systems that run multiple site instances, or single site instance, multiple times, in a VM, are parallel systems.

If you are only ever going to have a single user for your web site, and it’s not going to do any significant work on the back end, you might as well just run it on a laptop, because that way, if the power goes out, it has a built in UPS, in the laptop battery.

Anything that’s not a toy will require parallel and distributed systems, both, as separate things.


:::info{title="中文翻译"}
为什么计算机科学学生需要了解并行和分布式计算？

所有大型网站至少是分布式系统，以防止故障。

所有运行多个站点实例或在虚拟机中多次运行的系统都是并行系统。

如果你的网站只会有一个用户，并且在后端不会执行任何重要工作，最好直接在笔记本电脑上运行，因为这样，如果断电，它有内置的不间断电源，即笔记本电池。

任何不是玩具的东西都将需要并行和分布式系统，二者都是单独的事物。
:::

- **Computer Science Students:** 学习计算机科学的学生。
- **Parallel and Distributed Computing:** 并行和分布式计算，涉及同时处理多个任务和多台计算机共同完成任务的概念。
- **Large Websites:** 大型网站，规模庞大的互联网网站。
- **Distributed Systems:** 分布式系统，由多个相互连接的计算机组成的系统，实现协同工作。
- **Prevent Failures:** 防止故障，采取措施以防止系统或组件发生故障。
- **Multiple Site Instances:** 多个站点实例，一个系统的多个相同副本或实例。
- **Virtual Machines (VM):** 虚拟机，软件模拟的计算机系统，可以在物理计算机上运行多个操作系统。
- **Parallel Systems:** 并行系统，处理多个任务或操作的系统。
- **Laptop:** 笔记本电脑，便携式个人计算机。
- **Power Outage:** 断电，电源中断，停止电力供应。
- **Built-in Uninterruptible Power Supply (UPS):** 内置的不间断电源（UPS），在电源中断时提供短时电力供应的设备，以防止数据丢失或硬件损坏。
- **Toy:** 玩具，在此处指简单或基础的系统或项目。

英语翻译 18号

![image.png](/static/img/d808344917622fed7bd1282253bdcb1e.image.webp)

![image.png](/static/img/28f4bacf018e1dcb2dd5335a2473be39.image.webp)



![image.png](/static/img/4e842842b081f389140727f6c653e86e.image.webp)
```sql

CREATE TABLE Movies (
  movie_id INT PRIMARY KEY,
  title VARCHAR(100)
);

CREATE TABLE Users (
  user_id INT PRIMARY KEY,
  name VARCHAR(100)
);

CREATE TABLE MovieRating (
  movie_id INT,
  user_id INT,
  rating INT,
  created_at DATE,
  PRIMARY KEY (movie_id, user_id)
);


drop table Movies;


INSERT INTO Movies (movie_id, title) VALUES
  (1, 'Avengers'),
  (2, 'Frozen 2'),
  (3, 'Joker');

INSERT INTO Users (user_id, name) VALUES
  (1, 'Daniel'),
  (2, 'Monica'),
  (3, 'Maria'),
  (4, 'James');

INSERT INTO MovieRating (movie_id, user_id, rating, created_at) VALUES
  (1, 1, 3, '2020-01-12'),
  (1, 2, 4, '2020-02-11'),
  (1, 3, 2, '2020-02-12'),
  (1, 4, 1, '2020-01-01'),
  (2, 1, 5, '2020-02-17'),
  (2, 2, 2, '2020-02-01'),
  (2, 3, 2, '2020-03-01'),
  (3, 1, 3, '2020-02-22'),
  (3, 2, 4, '2020-02-25');


select r1.results from (

select u.name as results from  Users as u left join MovieRating as  m on
 u.user_id=m.user_id
group by u.user_id,u.name
order by count(u.user_id) desc,u.name asc
limit 1

) as r1

union all

select r2.results from (
  select m2.title as results from
  Movies as m2 left join MovieRating as m on
  m.movie_id=m2.movie_id
  and m.created_at like '2020-02%'
  group by m2.title
  order by avg(m.rating) desc,m2.title asc
  limit 1
) r2;





-- 查找评论电影数量最多的用户名
SELECT u.name AS results
FROM Users u
JOIN (SELECT user_id, COUNT(DISTINCT movie_id) AS num_movies
FROM MovieRating GROUP BY user_id
HAVING num_movies = (SELECT MAX(num_movies)
FROM (SELECT COUNT(DISTINCT movie_id) AS num_movies
FROM MovieRating GROUP BY user_id) t)) m ON u.user_id = m.user_id
ORDER BY u.name
LIMIT 1;


SELECT m.title AS results
FROM Movies m
JOIN (
    SELECT movie_id, AVG(rating) AS avg_rating
    FROM MovieRating
    WHERE created_at >= '2020-02-01' AND created_at < '2020-03-01'
    GROUP BY movie_id
    HAVING avg_rating = (
        SELECT MAX(avg_rating)
        FROM (
            SELECT movie_id, AVG(rating) AS avg_rating
            FROM MovieRating
            WHERE created_at >= '2020-02-01' AND created_at < '2020-03-01'
            GROUP BY movie_id
        ) t
    )
) r ON m.movie_id = r.movie_id
ORDER BY m.title
LIMIT 1;



SELECT results
FROM (
  SELECT name AS results, RANK() OVER(ORDER BY COUNT(*) DESC, name) AS RANKING
  FROM Users
  INNER JOIN MovieRating USING(user_id)
  GROUP BY user_id
  UNION ALL
  SELECT title AS results, RANK() OVER(ORDER BY AVG(rating) DESC, title) AS RANKING
  FROM MovieRating
  INNER JOIN Movies USING(movie_id)
  WHERE DATE_FORMAT(created_at, '%Y-%m') = '2020-02'
  GROUP BY movie_id
) T
WHERE T.RANKING = 1

```
## 窗口函数。
第一个子查询选择的是评论电影数量最多的用户名。通过内连接（INNER JOIN）Users和MovieRating表，使用user_id进行连接，并使用GROUP BY对user_id进行分组。然后使用RANK() OVER进行排名，根据评论数量降序排列，并根据用户名的字典序升序排列（如果评论数量相同）。
第二个子查询选择的是在2020年2月份平均评分最高的电影名称。通过内连接Movies和MovieRating表，使用movie_id进行连接，并使用WHERE子句筛选出2020年2月份的数据。然后使用GROUP BY对movie_id进行分组，计算平均评分。再使用RANK() OVER进行排名，根据平均评分降序排列，并根据电影名称的字典序升序排列（如果平均评分相同）。

![image.png](/static/img/45d64f3c89509e6e88547d70ffa6d501.image.webp)

![image.png](/static/img/cb684c2efc64b30db80b81e090e12618.image.webp)

```sql
CREATE TABLE Employees (
  id INT PRIMARY KEY,
  name VARCHAR(100)
);

CREATE TABLE EmployeeUNI (
  id INT,
  unique_id INT,
  PRIMARY KEY (id, unique_id)
);



INSERT INTO Employees (id, name) VALUES
  (1, 'Alice'),
  (7, 'Bob'),
  (11, 'Meir'),
  (90, 'Winston'),
  (3, 'Jonathan');

INSERT INTO EmployeeUNI (id, unique_id) VALUES
  (3, 1),
  (11, 2),
  (90, 3);


select unique_id,name from
Employees as e1 left join
EmployeeUNI as e2 on e1.id=e2.id ;
```

SQL语句练习18号

```go
// Copyright 2022 <mzh.scnu@qq.com>. All rights reserved. 
 // Use of this source code is governed by a BSD-style 
 // license that can be found in the LICENSE file. 
  
 package main 
  
 import ( 
         "flag" 
         "fmt" 
         "strings" 
  
         "google.golang.org/protobuf/compiler/protogen" 
 ) 
  
 func main() { 
         g := rpc{} 
  
         var flags flag.FlagSet 
         genCli := flags.Bool("gen-cli", false, "--tinyrpc_out=gen-cli=true:.") 
  
         protogen.Options{ 
                 ParamFunc: flags.Set, 
         }.Run(func(p *protogen.Plugin) error { 
                 err := g.Generate(p) 
                 if err != nil { 
                         return err 
                 } 
                 if *genCli { 
                         return generateCli(p) 
                 } 
                 return nil 
         }) 
 } 
  
 type rpc struct{} 
  
 // Generate generate service code 
 func (md *rpc) Generate(plugin *protogen.Plugin) error { 
         for _, f := range plugin.Files { 
                 if len(f.Services) == 0 { 
                         continue 
                 } 
                 fileName := f.GeneratedFilenamePrefix + ".svr.go" 
                 t := plugin.NewGeneratedFile(fileName, f.GoImportPath) 
                 t.P("// Code generated by protoc-gen-tinyrpc.") 
                 t.P() 
                 pkg := fmt.Sprintf("package %s", f.GoPackageName) 
                 t.P(pkg) 
                 t.P() 
                 for _, s := range f.Services { 
                         serviceCode := fmt.Sprintf(`%stype %s struct{}`, 
                                 getComments(s.Comments), s.Desc.Name()) 
                         t.P(serviceCode) 
                         t.P() 
                         for _, m := range s.Methods { 
                                 funcCode := fmt.Sprintf(`%sfunc(this *%s) %s(args *%s,reply *%s)error{ 
                                         // define your service ... 
                                         return nil 
                                 } 
                                 `, getComments(m.Comments), s.Desc.Name(), 
                                         m.Desc.Name(), m.Input.Desc.Name(), m.Output.Desc.Name()) 
                                 t.P(funcCode) 
                         } 
                 } 
         } 
         return nil 
 } 
  
 func generateCli(plugin *protogen.Plugin) error { 
         for _, f := range plugin.Files { 
                 if len(f.Services) == 0 { 
                         continue 
                 } 
                 fileName := f.GeneratedFilenamePrefix + ".cli.go" 
                 t := plugin.NewGeneratedFile(fileName, f.GoImportPath) 
                 t.P("// Code generated by protoc-gen-tinyrpc. DO NOT EDIT.") 
                 t.P() 
                 pkg := fmt.Sprintf("package %s", f.GoPackageName) 
                 t.P(pkg) 
                 t.P() 
                 importCode := `import ( 
                 "github.com/zehuamama/tinyrpc" 
                 "net" 
                 )` 
                 t.P(importCode) 
                 t.P() 
                 for _, s := range f.Services { 
                         clientCode := fmt.Sprintf(`%stype %sClient struct{ 
                                 client *tinyrpc.Client 
                         } 
                         `, 
                                 getComments(s.Comments), s.Desc.Name()) 
                         t.P(clientCode) 
                         t.P() 
                         newClientCode := fmt.Sprintf(`func New%sClient(conn net.Conn) %sClient { 
                                 return %sClient{client: tinyrpc.NewClient(conn)} 
                         } 
                         `, 
                                 s.Desc.Name(), s.Desc.Name(), s.Desc.Name()) 
                         t.P(newClientCode) 
                         t.P() 
                         for _, m := range s.Methods { 
                                 funcCode := fmt.Sprintf(`%sfunc(this *%sClient) %s(args *%s,reply *%s)error{ 
                                         return this.client.Call("%s.%s", args, reply) 
                                 } 
                                 `, getComments(m.Comments), s.Desc.Name(), 
                                         m.Desc.Name(), m.Input.Desc.Name(), m.Output.Desc.Name(), s.Desc.Name(), m.Desc.Name()) 
                                 t.P(funcCode) 
                         } 
                 } 
         } 
         return nil 
 } 
  
 // getComments get comment details 
 func getComments(comments protogen.CommentSet) string { 
         c := make([]string, 0) 
         c = append(c, strings.Split(string(comments.Leading), "\n")...) 
         c = append(c, strings.Split(string(comments.Trailing), "\n")...) 
  
         res := "" 
         for _, comment := range c { 
                 if strings.TrimSpace(comment) == "" { 
                         continue 
                 } 
                 res += "//" + comment + "\n" 
         } 
         return res 
 }

```