結對第二次—文獻摘要熱詞統計及進階需求
格式描述
- 課程名稱: 軟件工程實踐
- 做業要求: 結對第二次—文獻摘要熱詞統計及進階需求
- 結對學號: 221600412 | 221600411
- Fork同名倉庫的GitHub項目地址: GitHub地址
- GitHub代碼簽入記錄:
做業開發過程
- 團隊分工
- 221600411工做
- 需求分析
- 代碼開發（單元測試、微信小程序）
- 代碼測試
- 博客撰寫
- 設計函數流程圖
- 設計類圖極其關係
- 輔助開發
- 221600412工做
- 需求討論
- 代碼編寫
- 基本需求和進階需求的功能實現
- 代碼測試
- 博客撰寫
- 代碼壓力測試
- 代碼優化
- 附加題的數據分析與製圖
- 221600411工做
效能分析和PSPhtml
PSP是卡耐基梅隆大學（CMU）的專家們針對軟件工程師所提出的一套模型：Personal Software Process (PSP， 我的開發流程，或稱個體軟件過程)。
PSP2.1 Personal Software Process Stages 預估耗時（分鐘） 實際耗時（分鐘） Planning 計劃 0 0 Estimate 估計這個任務須要多少時間 900 1600 Development 開發 350 500 Analysis 需求分析 (包括學習新技術) 60 230 Design Spec 生成設計文檔 10 60 Design Review 設計複審 10 10 Coding Standard 代碼規範 (爲目前的開發制定合適的規範) 20 30 Design 具體設計 20 20 Coding 具體編碼 270 450 Code Review 代碼複審 10 20 Test 測試（自我測試，修改代碼，提交修改） 40 60 Reporting 報告 60 120 Test Report 測試報告 20 40 Size Measurement 計算工做量 10 20 Postmortem & Process Improvement Plan 過後總結, 並提出過程改進計劃 20 40 合計 900 1600
解題思路
- 需求分析
- 首先大概閱讀整個做業文檔，大體瞭解此次做業的主要任務。
- 將整個做業根據要求分紅基礎和進階，首先考慮完成基礎部分。兩人共同對做業文檔的基礎做業部分進行精細閱讀，概括出每部分的要求，便於後續的功能設計
- 對於做業文檔中感受有爭議的要求或理解，去羣裏尋找助教的熱情解答，私下與班級同窗共同探討對這個爭議的理解，結合百度查閱相關的資料
- 代碼實現與測試
- 對分析後的功能要求點，對代碼開發進行初步的設計（好比包的設計，團隊兩人約定贊成的代碼規範等），便於後續對代碼的管理
- 按照對代碼的設計進行代碼開發，開發過程當中碰到某個知識點忘記了，就進行百度查找答案
- 每開發一個功能就進行該功能的測試，防止後續測試尋找bug的工做量太大
- 基本功能實現後，進行各種數據和各項指標的測試
- 對代碼進行復查，補上開發過程漏掉的註釋等，方便後期的維護
代碼設計過程
- 基本需求
- 項目結構
221600412&221600411
|- src
|- Main.java(主程序，能夠從命令行接收參數)
|- lib.java(包含其它自定義函數，能夠有多個) - 函數關係與流程：
- 主要有兩個類 Main.java 和 Lib.java 爲了方便維護和修改 函數拆成四個 主要函數countChar，countWord，countLine，countMostWord，分別爲計算字符數，單詞數，行數，和輸出詞頻，經過主函數依次調用countChar，countWord，countLine，countMostWord去進行計算並輸出
- 項目結構
- 進階需求：
- 項目結構
- 221600412&221600411
|- src
|- Main.java(主程序，能夠從命令行接收參數)
|- lib.java(包含其它自定義函數，能夠有多個)
|- Main.class(編譯生成的可運行程序)
|- lib.class(編譯生成的可運行程序)
|- cvpr
|- result.txt(爬蟲結果)
|- Main. - 爬蟲使用工具 ：Java
- 爬蟲思路：首先進入CVPR官網對html文檔進行分析發現每篇論文都在的div.class="ptitle"中，因此程序先class選擇器（getElementByClass("ptitle")）獲取全部的div，接着使用元素選擇器（select（"a"））獲取其中的a標籤，最後分別用（attr("href")），和（text()）獲取href和文本的值，把獲取的連接和基礎的url拼接成論文的訪問地址，接着進入論文的詳情頁，ID選擇器getElementById("abstract")，獲取Div的id屬性爲abstract的元素並用text()獲取對應摘要的文本內容，而後依照格式輸出到指定的文件中。以下圖
- 標題和連接部分
- 摘要部分
- 主要有兩個類 Main.java 和 Lib.java，主函數接收命令行參數後，設置完變量並傳遞給Lib類，Lib類經過參數控制調用哪一個函數。主要函數countWordOrWordGroupAndFrequency，countWord，countWordGroup，printCountMostWord，經過函數countWordOrWordGroupAndFrequency進行控制調用那個函數和輸出
- 單元測試
- 每完成一項功能好比單詞數的統計，而後根據做業文檔儘量設計各類可能出現的輸入狀況進行測試統計，儘可能確保每項功能在開發完成後是沒有bug存在
- 對總的輸出進行測試並比對輸出的數據格式
- 最後對要上傳的代碼，先刪掉代碼中的中文字符和一些無用代碼註解 並用javac 和 java 進行編譯運行確保程序在提交後能正確編譯運行
- 單元測試圖
- 代碼組織與內部實現設計
- 基本需求類圖
- 進階需求類圖
- 基本需求類圖
- 算法的關鍵與關鍵實現部分流程圖
- 基本需求算法的關鍵主要是countChar，countWord，countLine，countMostWord
- 進階需求算法的關鍵主要是countWordOrWordGroupAndFrequency，countWord，countWordGroup，printCountMostWord
- 具體算法思路在 下面的代碼說明
- 基本需求流程圖以下
- 進階需求的流程圖以下
改進程序性能
- 花費的時間：120分鐘
- 改進思路 ：
- 對文件的讀取一開始分紅計算char，word，line分紅三個函數分別而後三個函數互相獨立，計算的時候分別讀取三次的文件IO，致使程序跑得慢，以後改進文件的讀取次數，主函數從文件讀取數據以後把數據存在內存中，而後在對內存中的數據進行操做，這樣只進行了一遍IO操做，節省了兩次IO。
- 把字符串切割成單詞，首先是最簡單的想法，直接double for 進行遍歷把分割符位置所有標出來，並進行切割。改進後：用單重for循環進行遍歷用標識符標識單詞的首尾，接着進行切割單詞並判斷是否爲題目所要求的單詞。改進後的結構爲O（n）
- 對於進階需求，雖然把功能也才成三個函數，但在處理數據的時候，只進行一遍的處理，也就是程序只進行一次IO和一次for循環，時間複雜度達到O（n）。思路就是建立幾個保存數據的字段，個人處理論文的方式，先把數據讀入到內存中，以後對論文進行切分，切分後一篇論文包含，編號，標題，和摘要，以後對這些數據分開處理，同時計算字符，單詞，行數，和詞組，對每篇論文處理的結果和字段中的結果累加，達到了只對數據處理一遍就能完成計算。
性能分析圖：
java- 消耗最大的函數countWord（）和 countGroupWord()
- 複雜度爲均爲 O（n） 都對數據進行一次遍歷 獲得計算結果
代碼說明
- 基本需求
- 思路與說明：首先程序從命令行讀取文件明，而後經過文件名對文件的內容進行讀取到字符串中，而後分別對這個字符串進行countChar，countWord，countLine，countMostWord，分別爲計算字符數，單詞數，行數，和輸出詞頻，經過主函數依次調用countChar，countWord，countLine，countMostWord去進行計算並輸出
- 主函數流程,依此調用函數並輸出到指定文件中
public static void main(String args[]) throws IOException { String content = readFile(args[0]); Lib lib = new Lib(); String str1 = lib.countChar(content); String str2 = lib.countWord(content); String str3 = lib.countLine(content); String str4 = lib.countMostWord(); writeFile("result.txt", str1 + "\r\n" + str2 + "\r\n" + str3 + "\r\n" + str4); } - countChar，對計算字符 一個特例 \r\n 這個本來ascii碼爲13，10算作兩個字符，做業要求只算一個字符因此關鍵代碼以下
public String countChar(String content) {
return "characters: " + content.replaceAll("\r\n", " ").toCharArray().length;
}
- countWord，對計算單詞,經過單層for循環進行遍歷，先找到兩個分隔符，而後用函數substring切出單詞並用toLowerCase所有轉成小寫，而後對這個單詞判斷是否爲 題目需求定義的單詞，是的話存放到Map中，不是的話繼續循環。
public String countWord(String content) {
int wordNum = 0;
char[] ch = content.toCharArray();
int begin = 0, end = 0, len = content.toCharArray().length;
String str = null;
for (int i = 0; i < len; i++) {
boolean flag = !((ch[i] >= 65 && ch[i] <= 90) || (ch[i] >= 97 && ch[i] <= 122) || (ch[i] >= 48 && ch[i] <= 57));
if (flag || i == 0) { // If it is a delimiter or the beginning of the calculation
if (flag) {
begin = end = i + 1;
} else {
begin = end = i;
}
// Find two delimiters
while (end < len && ((ch[end] >= 65 && ch[end] <= 90) ||
(ch[end] >= 97 && ch[end] <= 122) || (ch[end] >= 48 && ch[end] <= 57))) {
end++;
}
if (begin != end) {
i = end - 1;
if (end - begin >= 4) {
str = content.substring(begin, end).toLowerCase();
boolean isWord = true;
for (int j = 0; j < 4; j++) { // If the first four are letters
if (str.charAt(j) >= 48 && str.charAt(j) <= 57) {
isWord = false;
break;
}
}
if (isWord) {
wordNum++;
if (map.containsKey(str)) {
map.put(str, map.get(str) + 1);
} else {
map.put(str, 1);
}
}
}
}
} else {
continue;
}
}
return "words: " + wordNum;
}
- 對於計算行數，經過循環先判斷有沒有非空白字符，有非空白字符的話進行標記，直到找到回車換行符而後，結束
public String countLine(String content) {
int len = content.toCharArray().length;
char[] ch = content.toCharArray();
int line = 0;
boolean flag = false;
for (int i = 0; i < len; i++) {
while (i + 1 < len) { // /r/n Text wrap skips calculations
if ((ch[i] == 13 && ch[i + 1] == 10)) {
break;
}
if ((ch[i] >= 0 && ch[i] <= 32) || ch[i] == 127) { // Is a blank character
i++;
continue;
} else {
i++;
flag = true;
}
}
if( i + 1 == len && ! ((ch[i] >= 0 && ch[i] <= 32) || ch[i] == 127)){
flag = true;
}
i = i + 1;
if (flag) {
line++;
flag = false;
}
}
return "lines: " + line;
}
- 輸出詞頻，上面把全部的單詞存放到map中，經過這個函數對mao進行排序以後輸出
// Computing word frequency
public String countMostWord() {
// Sort the keys in the HashMap and display the sorted results
List<Map.Entry<String, Integer>> infoIds = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
// Sort the keys in the HashMap
Collections.sort(infoIds, new Comparator<Map.Entry<String, Integer>>() {
public int compare(Map.Entry<String, Integer> o1,
Map.Entry<String, Integer> o2) {
if (o1.getValue() == o2.getValue()) {
return o1.getKey().compareTo(o2.getKey());
}
return -(o1.getValue() - o2.getValue());
}
});
StringBuilder sb = new StringBuilder();
// The output frequency
for (int i = 0; i < infoIds.size() && i < 10; i++) {
sb.append("<" + infoIds.get(i).getKey() + ">: " + infoIds.get(i).getValue() + "\r\n");
}
return sb.toString();
}
- 進階需求
- 思路與說明
- 爬蟲思路在上面已提到
- 主函數經過接收命令行參數，並調用相對應的函數，對一些字段進行設置值，而後經過調用Lib類中的countWordOrWordGroupAndFrequency函數進行計算，最後輸出到指定的文件中
- 思路與說明
public String inputFileName = null; // The file name to read
public String outputFileName = null; // The file name to output
public int titleWeight = 10; // title weight
public int abstractWeight = 1; // abstract weight
public int m = 1; // The length of the phrase
public int n = 10; // Output the number of words
public static void main(String args[]) throws IOException {
Main instance = new Main();
for (int i = 0; i < args.length; i++) {
switch (args[i]) {
case "-i":
instance.I(args[i + 1]);
break;
case "-o":
instance.O(args[i + 1]);
break;
case "-w":
instance.W(args[i + 1]);
break;
case "-m":
instance.M(args[i + 1]);
break;
case "-n":
instance.N(args[i + 1]);
break;
default:
break;
}
}
String content = instance.readFile(instance.inputFileName);
Lib lib = new Lib();
lib.countWordOrWordGroupAndFrequency(content, instance.titleWeight, instance.abstractWeight, instance.m, instance.n); // 計算單詞總數
String str1 = lib.printChar(); // calculate Number of characters
String str2 = lib.printWord(); // Count words
String str3 = lib.printLines(); // Calculate number of lines
String str4 = lib.printCountMostWord(instance.n);// Computing word frequency
instance.writeFile(instance.outputFileName,str1 + "\r\n" + str2 + "\r\n" + str3 + "\r\n" + str4);
}
public void I(String str) {
inputFileName = str;
}
public void O(String str) {
outputFileName = str;
}
public void W(String str) {
if (Integer.valueOf(str) == 0) {
titleWeight = abstractWeight = 1;
} else if (Integer.valueOf(str) == 1) {
titleWeight = 10;
abstractWeight = 1;
}
}
public void M(String str) {
m = Integer.valueOf(str);
}
public void N(String str) {
n = Integer.valueOf(str);
}
- countWordOrWordGroupAndFrequency接收一系列的參數( content, int w1, int w2, int m1, int n1),而後分別對content進行論文切分，經過論文之間的兩個回車換行符把論文分開，對每篇論文也用回車換行進行切分，分紅編號，標題和摘要。以後對標題和摘要分別進行統計,統計後存放在字段中，以後調用printChar，printWord，printLines，printCountMostWord輸出到指定文件中
public void countWordOrWordGroupAndFrequency(String content, int w1, int w2, int m1, int n1) {
titleWeight = w1;
abstractWeight = w2;
m = m1;
n = n1;
boolean isWordGroup = false;
if (m >= 2) {
isWordGroup = true;
}
String[] attr = content.split("\r\n\r\n");
String[] str = null;
String t1 = null;
String t2 = null;
for (int i = 0; i < attr.length; i++) {
if (attr[i] != null && !attr[i].equals("")) {
if (i == 0) {
str = attr[i].split("\r\n");
} else {
str = attr[i].replaceFirst("\r\n", "").split("\r\n");
}
if (str.length == 3) {
t1 = str[1].substring(7);
t2 = str[2].substring(10);
lines += 2; // add line
charNum += 2; // add line
countChar(t1 + t2);
if (isWordGroup) {
countWordGroup(t1, true); // Calculate the title
countWordGroup(t2, false); // Calculated in this paper,
} else {
countWord(t1, true); // Calculate the title
countWord(t2, false); // Calculated in this paper
}
}
}
}
}
- countWord，countWordGroup 兩個算法思路很類似，都是先進行切分單詞，對於countWordGroup切分後的第一個單詞標記起始位置若是連續m個都爲單詞，切出起始位置和末尾的位置，而後存到map中，存放的時候由於上面已經把title和摘要進行了分開計算因此在存放的時候，能知道當處理的是摘要仍是標題，而後用正確的權重去加權，最後調用排序算法後輸出。
public void countWordOrWordGroupAndFrequency(String content, int w1, int w2, int m1, int n1) {
titleWeight = w1;
abstractWeight = w2;
m = m1;
n = n1;
boolean isWordGroup = false;
if (m >= 2) {
isWordGroup = true;
}
String[] attr = content.split("\r\n\r\n");
String[] str = null;
String t1 = null;
String t2 = null;
for (int i = 0; i < attr.length; i++) {
if (attr[i] != null && !attr[i].equals("")) {
if (i == 0) {
str = attr[i].split("\r\n");
} else {
str = attr[i].replaceFirst("\r\n", "").split("\r\n");
}
if (str.length == 3) {
t1 = str[1].substring(7);
t2 = str[2].substring(10);
lines += 2; // add line
charNum += 2; // add line
countChar(t1 + t2);
if (isWordGroup) {
countWordGroup(t1, true); // Calculate the title
countWordGroup(t2, false); // Calculated in this paper,
} else {
countWord(t1, true); // Calculate the title
countWord(t2, false); // Calculated in this paper
}
}
}
}
}
// Count words
public void countWord(String content, boolean isTitle) {
char[] ch = content.toCharArray();
int begin = 0, end = 0, len = content.toCharArray().length;
String str = null;
for (int i = 0; i < len; i++) {
boolean flag = !((ch[i] >= 65 && ch[i] <= 90) || (ch[i] >= 97 && ch[i] <= 122) || (ch[i] >= 48 && ch[i] <= 57)); // 判斷是不是分隔符
if (flag || i == 0) { // If it is a delimiter or the beginning of the calculation
if (flag) {
begin = end = i + 1;
} else {
begin = end = i;
}
// Find two delimiters
while (end < len && ((ch[end] >= 65 && ch[end] <= 90) ||
(ch[end] >= 97 && ch[end] <= 122) || (ch[end] >= 48 && ch[end] <= 57))) {
end++;
}
if (begin != end) {
i = end - 1;
if (end - begin >= 4) {
str = content.substring(begin, end).toLowerCase();
boolean isWord = true;
for (int j = 0; j < 4; j++) { // If the first four are letters
if (str.charAt(j) >= 48 && str.charAt(j) <= 57) {
isWord = false;
break;
}
}
if (isWord) {
wordNum++;
if (map.containsKey(str)) {
if (isTitle) {
map.put(str, map.get(str) + titleWeight);
} else {
map.put(str, map.get(str) + abstractWeight);
}
} else {
if (isTitle) {
map.put(str,titleWeight);
} else {
map.put(str,abstractWeight);
}
}
}
}
}
} else {
continue;
}
}
}
// Computing phrase
public void countWordGroup(String content, boolean isTitle) {
char[] ch = content.toCharArray();
int wordGroupBegin = 0, wordGroupEnd = 0;
int firstWordEnd = 0;
int begin = 0, end = 0, len = content.toCharArray().length;
String str = null;
int wordGroupNum = 0;
for (int i = 0; i < len; i++) {
boolean flag = !((ch[i] >= 65 && ch[i] <= 90) || (ch[i] >= 97 && ch[i] <= 122) || (ch[i] >= 48 && ch[i] <= 57)); // Determines if it is a delimiter
if (flag || i == 0) { // If it is a delimiter or the beginning of the calculation
if (flag) {
begin = end = i + 1;
} else {
begin = end = i;
}
// Find two delimiters
while (end < len && ((ch[end] >= 65 && ch[end] <= 90) ||
(ch[end] >= 97 && ch[end] <= 122) || (ch[end] >= 48 && ch[end] <= 57))) {
end++;
}
if (begin != end) {
i = end - 1;
if (end - begin < 4) {
wordGroupNum = 0;
}
if (end - begin >= 4) {
str = content.substring(begin, end).toLowerCase();
boolean isWord = true;
for (int j = 0; j < 4; j++) { // If the first four are letters
if (str.charAt(j) >= 48 && str.charAt(j) <= 57) {
isWord = false;
wordGroupNum = 0;
break;
}
}
if (isWord) {
wordNum++;
wordGroupNum++;
if (wordGroupNum == 1) {
wordGroupBegin = begin;
firstWordEnd = end;
}
if (wordGroupNum == m) {
wordGroupEnd = end;
str = content.substring(wordGroupBegin, wordGroupEnd).toLowerCase();
if (map.containsKey(str)) {
if (isTitle) {
map.put(str, map.get(str) + titleWeight);
} else {
map.put(str, map.get(str) + abstractWeight);
}
} else {
if (isTitle) {
map.put(str,titleWeight);
} else {
map.put(str,abstractWeight);
}
}
wordGroupNum = 0;
i = firstWordEnd - 1;
wordNum = wordNum - m +1 ;
}
} else {
wordGroupNum = 0;
}
}
}
} else {
continue;
}
}
}
單元測試代碼
- 測試代碼
@org.junit.Test
public void Test10() throws IOException {
String arg = "H:\\javaweb代碼\\qqqqq\\src\\main\\java\\軟工實踐_test\\input.txt";
String content = readFile(arg);
Lib lib = new Lib();
String str1 = lib.countChar(content); // 計算 字符數
String str2 = lib.countWord(content); // 計算單詞總數
String str3 = lib.countLine(content); // 計算行數
String str4 = lib.countMostWord();// 計算詞頻
String test1="characters: 99";
String test2="words: 20";
String test3="lines: 20";
String test4="<aaaa>: 4\n" +
"<bbbb>: 1\n" +
"<cccc>: 1\n" +
"<dddd>: 1\n" +
"<eeee>: 1\n" +
"<ffff>: 1\n" +
"<gggg>: 1\n" +
"<hhhh>: 1\n" +
"<iiii>: 1\n" +
"<jjjj>: 1\n";
Assert.assertEquals(str1,test1);
Assert.assertEquals(str2,test2);
Assert.assertEquals(str3,test3);
Assert.assertEquals(str4,test4);
}
- 部分測試數據
qq q qqq qqq.qqq q www w www 結果 characters: 35 words: 0 lines: 2
a
b
c
d
結果
characters: 11
words: 0
lines: 4
abcdefghijklmnopqrstuvwxyz
1234567890
,./;'[]\<>?:"{}|`-=~!@#$%^&*()_+
結果
characters: 76
words: 1
lines: 3
<abcdefghijklmnopqrstuvwxyz>: 1
- 測試的思路與想法
- 測試的思路與想法主要在於對各類不知足條件的情形進行測試，特別是在臨界條件，測試程序可否正確統計各類特殊狀況
- 開頭帶有空格、tab的情形
- 整個文檔只有空白字符的情形
- 對於單詞的檢查，根據要求設計各類不知足的狀況，觀察是否能夠正確統計
- 針對空白字符，設計多種狀況進行測試
- 對回車換行作獨立的測試
- 對\r\n的特殊輸入進行測試
- 對各種邊界條件進行屢次反覆的測試
- 測試的思路與想法主要在於對各類不知足條件的情形進行測試，特別是在臨界條件，測試程序可否正確統計各類特殊狀況
困難及解決和評價隊友
- 評價221600411
- 值得學習的地方:對做業一絲不苟，對程序的測試很是嚴謹，流程圖和類圖製做得很好,獨立完成附加小程序的編碼工做
- 須要改進的地方：須要增強時間的管理，平衡好做業和其餘的時間。
- 評價221600412
- 值得學習的地方：動手實踐能力較強，獨自完成了大部分的編碼工做，盡本身最大的能力完成做業。
- 須要改進的地方：需平衡好時間的，增強理論的學習
- 所遇困難
- 需求理解花了許多時間去理解，有些需求理解錯誤致使程序屢次變更
- 一些程序軟件沒有安裝，好比性能測試工具
- 解決辦法
- 查找助教的解答，與同窗探討
- 經過百度查閱相關資料進行安裝和操做
附加題設計與展現
- 數據分析使用python 庫
- 數據分析
- 分別對標題和摘要進行了詞頻統計並輸出成 詞雲
- 標題詞雲
- 摘要詞雲
下圖爲對做者發表論文的svg圖顯示前30位 連接 點擊連接能夠在網站上查看svg圖下圖只有靜態效果
python- 設計的創意
- 針對進階要求所爬取的數據繁多，在控制檯的查看較爲費勁，便開發論文列表的界面，便於用戶對爬取的論文進行瀏覽；考慮到提升用戶的簡便程度，決定使用微信小程序進行簡單的界面顯示
- 實現思路
- 後端使用java開發接口，將爬取的數據存取在數據庫，經過接口與微信小程序對接，傳遞數據，實現論文列表的界面顯示與瀏覽
實現成果的展現
git詞頻分析 代碼下載github
心得體會web
陳迎仁
心得與總結算法
經過此次做業學會了許多除了編寫代碼外的知識，好比GitHub的上傳，單元測試的含義，以及測試數據的設計，等各類非代碼類的技能。固然在代碼這方面也提高很多，主要在於測試階段，設計各種流程圖以及類圖還有微信小程序的界面開發以及博客文檔的撰寫，輔助隊友進行代碼開發。經過此次團隊做業，我進一步對團隊協做有了深的理解，一我的完成代碼開發以及測試真的工做量大，並且在對於測試，客觀性不夠強，團隊配合測試，所使用的測試用例可能更加的全面以及更可以保證測試結果的正確性。總之在此次軟工實踐做業中，雖然花費的時間較多，可是也學到了許多新的技能。累但值得哈哈哈！數據庫
陳宇
心得與總結小程序
此次做業的做業量雖然很大，可是經過此次做業我學到了不少東西，好比一個明確的需求有多重要，這個做業的需求研究了好幾天，最後仍是經過微信羣裏的同窗進行了討論，還有助教的回答。以後就是編碼和測試，在編碼的過程當中，一開始對需求的不明確致使一直修改代碼，後面等肯定了需求後在寫以後進度快了好多，編寫完代碼以後就和隊友一塊兒測試代碼，調試代碼，知道程序的運行的結果和周圍隊友的結果一致，雖然此次做業花了不少的時間，也學到了不少的東西，也學到了不少和團隊配合的東西。後端
相關文章
- 1. 結對第二次—文獻摘要熱詞統計及進階需求
- 2. 結對第二次——文獻摘要熱詞統計及進階需求
- 更多相關文章...
- • C# 二進制文件的讀寫 - C#教程
- • 瀏覽器 統計 - 瀏覽器信息
- • Docker容器實戰(七) - 容器眼光下的文件系統
- • 算法總結-二分查找法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 字節跳動21屆秋招運營兩輪面試經驗分享
- 2. Java 3 年，25K 多嗎？
- 3. mysql安裝部署
- 4. web前端開發中父鏈和子鏈方式實現通信
- 5. 3.1.6 spark體系之分佈式計算-scala編程-scala中trait特性
- 6. dataframe2
- 7. ThinkFree在線
- 8. 在線畫圖
- 9. devtools熱部署
- 10. 編譯和鏈接
歡迎關注本站公眾號,獲取更多信息
