# Summer internship schedule

## Schedule

| Dates | Task (theoretical) | Task (practical) | Expected result |
|--------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 17.06-22.06 | - [[100%]](https://hackmd.io/IdXM-agMRaCbVuMMT_8idA?view#Figure-out-info-stored-in-hashgraph) figure out information that needs to be stored in the hashgraph, read material on torfs<br>- [[100%]](https://hackmd.io/IdXM-agMRaCbVuMMT_8idA?view#Testsrequirements-of-the-system) determine tests and requirements the system should satisfy (close to implementation, e.g. call `function1` with following args...)<br>- [[100%]](https://hackmd.io/IdXM-agMRaCbVuMMT_8idA?view#Look-into-existing-hashgraph-implementations) look at different hashgraph implementations, take note of pros/cons, programming language, build system, external libraries, test relevance and presence | - clone code of the solutions, compile it<br>- run autotests if present<br>- try to test manually (play with them)<br>- write some tests drafts for the system | Successfully running code cloned from repos.<br>Drafts of tests implementation for the system.<br>Report containing:<br> - what do we want to store in hashgraph<br> - test specifications, scenarios the system should sustain<br> - solutions with pros/cons<br> - chosen solution with reasoning behind the choice<br> - links to relevant resource |
| 22.06-25.06 | - [[100%]](https://hackmd.io/ReLx3kUVSker8TMAmZQ1nQ#What-we-want-from-API) draft an api between consensus protocol and the system, determine requirements<br>- [[100%]](https://hackmd.io/ReLx3kUVSker8TMAmZQ1nQ#Proposed-archtectures) check if libp2p-like api suits this purpose<br>- [[100%]](https://hackmd.io/ReLx3kUVSker8TMAmZQ1nQ#Proscons-of-each-approach) discuss the approaches, their pros and cons<br>- [[100%]](https://hackmd.io/ReLx3kUVSker8TMAmZQ1nQ#Tests-update) use tests from previous step as reference and update them if required<br>- [[100%]](https://hackmd.io/ReLx3kUVSker8TMAmZQ1nQ#API-specification) write API specification | - write prototypes of api to check them if needed<br>- create needed interfaces for the chosen api<br>- write tests for the interfaces | Report containing:<br> - api specification<br> - reasoning behind decisions made for API (how it helps with achieving our goals)<br> - decision about libp2p (use their design or not?)<br> - links to resources read/code written<br>Interface written in chosen language that represent the API. |
| 26.06-30.06<br>(could be split to several<br> intervals after API specs) | - [[100%]](https://hackmd.io/1nhlrHUeQZO1dIV92cqlFg?view#Testing-setup-clarifications) Write findings on things requested on the meeting<br>- enhance API docs if needed<br>- [[100%]](https://hackmd.io/ReLx3kUVSker8TMAmZQ1nQ#Proposed-archtectures) start looking into network reconfiguration<br>- [[100%]](https://hackmd.io/1nhlrHUeQZO1dIV92cqlFg#Network-reconfiguration) start researching "snapshot" system<br>- report test results<br><br>- [[100%]] write down interfaces according to API specs | - [80%] Write scripts to run the system automatically<br>- fit the implementation into chosen API<br>- run tests for the API<br>- write and run new tests that come to mind | Report with:<br> - changes made (if any) and reasons for them - decisions made when refactoring/rewriting - new written tests (if any)Doc with some info found on "snapshots" and reconfiguration.<br>Hashgraph implementation that works with predefined API. Successfully passing tests. |
| 01.07-05.07 | - write documentation to the code<br>- [[100%]](https://hackmd.io/h4IK-VKIRq6O9ZDMlFWGAA?view#Integration-approach) documents design decisions<br>- [[100%]](https://hackmd.io/h4IK-VKIRq6O9ZDMlFWGAA?view#Memory-safety) document memory/synchronisation safety status | - [100%] implement connection (per peer) handlers<br>- [100%] implement protocol module - message exchanging, etc.<br>- [100%] implement node behaviour - module connecting processor, memories, consensus, the library<br>- [100%] implement mock versions of components (to test behaviour/networking)<br>- [100%] add logging where applicable<br>- [100%] fit data memory implementation to the new system layout/api<br>- [100%] fit processor in the new system<br>- [100%] fit consensus into our system<br>- [100%] write unit tests where applicable<br>- [100%] run the tests on the whole system | Report with:<br> - changes made (if any) and reasons for them<br> - decisions made when refactoring/rewriting<br> - new written tests (if any)<br>Completed document on "snapshotting"/reconfiguration with:<br> - existing approaches<br> - our thoughts on them and how they fit our purpose<br>Final document draft with:<br> - work done<br> - how system works |
| 06.07-09.07 | - write about findings on reconfiguration, "snapshotting" to final report<br>- report system behaviour under various tests<br>- finalise the document<br>- report test results<br>- [100%] document the system | - [60%] run various tests on the system<br>- [100%] fix if something breaks | Final report with:<br> - what was given<br> - what we decided to do<br> - how we changed the system<br> - results of tests<br> - potential problems<br> - thoughts on further work |

## Reports

- [Report 1](https://hackmd.io/IdXM-agMRaCbVuMMT_8idA)
- [Report 2](https://hackmd.io/ReLx3kUVSker8TMAmZQ1nQ)
- [Report 3](https://hackmd.io/1nhlrHUeQZO1dIV92cqlFg)
- [Report 4](https://hackmd.io/h4IK-VKIRq6O9ZDMlFWGAA)

## Additional questions to (maybe) answer for each part

| Task | Questions to be answered or results |
|-----------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Checking existing hashgraph implementations | Is the documentation clear? Which implementation is the most suitable for basing the work on? Language, libs, build system, test analysis? How the implementation is integrated with other systems? Does it allow changing number of nodes? Does it have snapshot-like behavior? |
| API system-consensus | How much code rewriting is required for this change? Is this setup extensible for future features (at least for ones listed here)? Do we need to use new libraries? |
| libp2p decision | What would be the benefits of such transition? How much time will it take? Is it worth spending time on? |
| Other erasure codes (we don't plan to read but I put it just in case) | Does an approach allow system reconfiguration (changing nodes number)? How performant is setup/operations on data? How much data overhead does it introduce? Does it allow binary operations on encoded data? How secure is it? |
| Other possible consensus protocols | How secure is the consensus? How performant is it? Does it rely on timeouts? Does it have relevant builtin mechanisms (dynamic network size, snapshots, etc.)? |
| Hashgraph network reconfiguration | Does it fit our data model (if chosen)? How secure is this change? How much computations are required to reconfigure the network? How reliable is this approach? Can it work in the middle of computations? |
| Snapshots system | How to synchronise snapshots between peers? How to make sure the snapshot is legitimate? How frequent? How nodes with old state should catch up? How to synchronise the state with new nodes? |
| Dynamic node number | How it is performed in existing systems? How to do it in a secure way (e.g. with sybil attack resistance)? How to update data configuration? Performance? |
| Demo of the system running (with knocking out nodes etc.) | Does the system sustain <1/3 of nodes becoming unavailable? How performant is the system? How malicious behaviour is prevented? |
| Final report | How the system improved? How does it perform in various scenarios? What are the possible weaknesses? System characteristics (performance, security, functionality, features). What are the further steps? |