text:
- AI
    - [美团机器学习实践](/AI/2018-美团机器学习实践.md)
    - Application
      - RecommendSystem
        - [推荐系统实践篇](/AI/Application/RecommendSystem/2016-推荐系统实践篇.md)
        - [推荐系统理论篇](/AI/Application/RecommendSystem/2016-推荐系统理论篇.md)
        - [架构师 用户画像实践](/AI/Application/RecommendSystem/2017-架构师-用户画像实践.md)
    - ComputerVision
      - [图像处理、分析与机器视觉 3rd](/AI/ComputerVision/2010-图像处理、分析与机器视觉-3rd.md)
    - DeepLearning
      - [Bengio 深度学习](/AI/DeepLearning/2017-Bengio-深度学习.md)
      - [魏秀参 解析卷积神经网络与深度学习实践手册](/AI/DeepLearning/2017-魏秀参-解析卷积神经网络与深度学习实践手册.md)
      - [Liang 机器学习笔记](/AI/DeepLearning/2019-Liang-机器学习笔记.md)
      - [SteveZhu 一份简短的深度学习笔记](/AI/DeepLearning/2020-SteveZhu-一份简短的深度学习笔记.md)
    - MachineLearning
      - [Machine Learning A Probabilistic Perspective](/AI/MachineLearning/2012-Machine%20Learning%20A%20Probabilistic%20Perspective.md)
      - [Machine Learning in Action](/AI/MachineLearning/2012-Machine%20Learning%20in%20Action.md)
      - [李航 统计学习方法](/AI/MachineLearning/2012-李航-统计学习方法.md)
      - [DataScience From Scratch](/AI/MachineLearning/2014-DataScience-From-Scratch.md)
      - [Beating Kaggle the Easy Way](/AI/MachineLearning/2015-Beating%20Kaggle%20the%20Easy%20Way.md)
      - [Data Mining The Textbook](/AI/MachineLearning/2015-Data%20Mining-The%20Textbook.md)
      - [Python Data Science Essentials](/AI/MachineLearning/2015-Python%20Data%20Science%20Essentials.md)
      - [Text Data Management and Analysis](/AI/MachineLearning/2015-Text%20Data%20Management%20and%20Analysis.md)
      - [AndrewNG Machine Learning Yearning](/AI/MachineLearning/2016-AndrewNG-Machine%20Learning%20Yearning.md)
      - [周志华 机器学习](/AI/MachineLearning/2016-周志华-机器学习.md)
      - [诸葛越 百面机器学习](/AI/MachineLearning/2018-诸葛越-百面机器学习.md)
      - [Liang 机器学习笔记](/AI/MachineLearning/2019-Liang-机器学习笔记.md)
    - Mathematics
      - [概率论与数理统计 4th](/AI/Mathematics/2008-概率论与数理统计-4th.md)
      - [统计学完全教程](/AI/Mathematics/2008-统计学完全教程.md)
      - [All of Statistics A Concise Course in Statistical Inference ](/AI/Mathematics/2010-All%20of%20Statistics-A%20Concise%20Course%20in%20Statistical%20Inference%20.md)
      - [Fundamentals of Linear Algebra and Optimization](/AI/Mathematics/2017-Fundamentals%20of%20Linear%20Algebra%20and%20Optimization.md)
      - [G. Casella An Introduction to Statistical Learning](/AI/Mathematics/2017-G.%20Casella-An%20Introduction%20to%20Statistical%20Learning.md)
      - [Mathematics for Computer Science](/AI/Mathematics/2017-Mathematics%20for%20Computer%20Science.md)
    - NLP
      - [A Primer on Neural Network Models for Natural Language Processing](/AI/NLP/2015-A%20Primer%20on%20Neural%20Network%20Models%20for%20Natural%20Language%20Processing.md)
      - [Text Data Management and Analysis](/AI/NLP/2015-Text%20Data%20Management%20and%20Analysis.md)
      - [中文信息处理发展报告](/AI/NLP/2016-中文信息处理发展报告.md)
      - [Li Deng Deep Learning in Natural Language Processing](/AI/NLP/2017-Li%20Deng-Deep%20Learning%20in%20Natural%20Language%20Processing.md)
      - [Dan Jurafsky Speech and Language Processing 3rd](/AI/NLP/2018-Dan%20Jurafsky-Speech%20and%20Language%20Processing-3rd.md)
  - Architecture
    - [软件工程：实践者的研究方法](/Architecture/2009-软件工程：实践者的研究方法.md)
    - AlgoDS
      - [Knuth The Art of Computer Programming](/Architecture/AlgoDS/1997-Knuth-The%20Art%20of%20Computer%20Programming.md)
      - [Mathematics for Computer Science](/Architecture/AlgoDS/2015-Mathematics%20for%20Computer%20Science.md)
      - [Algorithm Design Parallel and Sequential](/Architecture/AlgoDS/2017-Algorithm%20Design%20Parallel%20and%20Sequential.md)
      - [Antti Competitive Programmer’s Handbook](/Architecture/AlgoDS/2017-Antti-Competitive%20Programmer’s%20Handbook.md)
      - [JeffE Algorithms](/Architecture/AlgoDS/2018-JeffE-Algorithms.md)
    - ArchitecturePattern
      - [Martin Fowler 企业应用架构模式](/Architecture/ArchitecturePattern/2006-Martin%20Fowler-企业应用架构模式.md)
      - [Eric 领域驱动设计：软件核心复杂性应对之道](/Architecture/ArchitecturePattern/2010-Eric-领域驱动设计：软件核心复杂性应对之道.md)
      - [Vaughn Implementing Domain Driven Design](/Architecture/ArchitecturePattern/2013-Vaughn-Implementing%20Domain%20Driven%20Design.md)
      - [简约之美：软件设计之道](/Architecture/ArchitecturePattern/2013-简约之美：软件设计之道.md)
      - [Practical Scalability Analysis With The Universal Scalability Law](/Architecture/ArchitecturePattern/2015-Practical%20Scalability%20Analysis%20With%20The%20Universal%20Scalability%20Law.md)
      - [Scott Patterns, Principles, and Practices of Domain Driven Design](/Architecture/ArchitecturePattern/2015-Scott-Patterns,%20Principles,%20and%20Practices%20of%20Domain%20Driven%20Design.md)
      - [架构师 架构漫谈](/Architecture/ArchitecturePattern/2016-架构师-架构漫谈.md)
      - [Martin Fowler Clean Architecture A Craftsman's Guide](/Architecture/ArchitecturePattern/2017-Martin%20Fowler-Clean%20Architecture%20A%20Craftsman's%20Guide.md)
      - [Martin Fowler 架构整洁之道](/Architecture/ArchitecturePattern/2017-Martin%20Fowler-架构整洁之道.md)
      - [John Ousterhout A Philosophy of Software Design](/Architecture/ArchitecturePattern/2018-John%20Ousterhout-A%20Philosophy%20of%20Software%20Design.md)
      - [Martin Fowler Refactoring Improving the Design of Existing Code](/Architecture/ArchitecturePattern/2018-Martin%20Fowler-Refactoring%20Improving%20the%20Design%20of%20Existing%20Code.md)
      - [面向模式的软件架构](/Architecture/ArchitecturePattern/面向模式的软件架构.md)
    - ArchitectureStyle
      - [Roy Thomas Fielding 架构风格与基于网络的软件架构设计](/Architecture/ArchitectureStyle/2000-Roy%20Thomas%20Fielding-架构风格与基于网络的软件架构设计.md)
      - [Martin Fowler Clean Architecture A Craftsman's Guide](/Architecture/ArchitectureStyle/2017-Martin%20Fowler-Clean%20Architecture%20A%20Craftsman's%20Guide.md)
    - DesginPattern
      - [Design Patterns Elements of Reusable Object Oriented Software](/Architecture/DesginPattern/1997-Design%20Patterns%20Elements%20of%20Reusable%20Object%20Oriented%20Software.md)
    - Workflow
      - [Phodal Growth: 全栈增长工程师指南](/Architecture/Workflow/2015-Phodal-Growth:%20全栈增长工程师指南.md)
      - Git
        - [Lynn Git Magic](/Architecture/Workflow/Git/2007-Lynn-Git%20Magic.md)
        - [Git Notes For Professionals](/Architecture/Workflow/Git/2017-Git%20Notes%20For%20Professionals.md)
  - Backend
    - HA
      - [Building Secure & Reliable Systems](/Backend/HA/2020-Building%20Secure%20&%20Reliable%20Systems.md)
    - MicroService
      - [Nginx MicroServices Reference Architecture](/Backend/MicroService/2017-Nginx-MicroServices%20Reference%20Architecture.md)
      - [Re 从 0 开始的微服务架构](/Backend/MicroService/2017-Re-从%200%20开始的微服务架构.md)
      - [微服务与 DevOps 内参](/Backend/MicroService/2017-微服务与%20DevOps%20内参.md)
      - [架构师 探索 Service 本源](/Backend/MicroService/2017-架构师-探索%20Service%20本源.md)
  - Business
    - 产品
      - [人人都是产品经理](/Business/产品/2009-人人都是产品经理.md)
      - [启示录，打造用户喜爱的产品](/Business/产品/2011-启示录，打造用户喜爱的产品.md)
      - [用户故事地图](/Business/产品/2016-用户故事地图.md)
    - 创业
      - [四步创业法](/Business/创业/2003-四步创业法.md)
      - [埃里克 精益创业](/Business/创业/2012-埃里克-精益创业.md)
      - [从 0 到 1，开启商业与未来的秘密](/Business/创业/2015-从%200%20到%201，开启商业与未来的秘密.md)
    - 商业
      - [凯恩斯 国富论](/Business/商业/凯恩斯-国富论.md)
      - [勒庞 乌合之众](/Business/商业/勒庞-乌合之众.md)
      - [小岛经济学](/Business/商业/小岛经济学.md)
      - [曼昆 经济学原理](/Business/商业/曼昆-经济学原理.md)
      - [格拉德威尔 引爆流行](/Business/商业/格拉德威尔-引爆流行.md)
      - [波特 竞争三部曲](/Business/商业/波特-竞争三部曲.md)
      - [菲利普·科特勒 营销管理](/Business/商业/菲利普·科特勒-营销管理.md)
      - [萨缪尔森 经济学](/Business/商业/萨缪尔森-经济学.md)
      - [马克思 资本论](/Business/商业/马克思-资本论.md)
    - 思维
      - [必然](/Business/思维/2016-必然.md)
    - 管理
      - [人月神话](/Business/管理/2003-人月神话.md)
      - [项目管理知识体系指南](/Business/管理/2013-项目管理知识体系指南.md)
    - 设计
      - [设计心理学](/Business/设计/2002-设计心理学.md)
      - [Don The Design of Everyday Things](/Business/设计/2013-Don-The%20Design%20of%20Everyday%20Things.md)
      - [Steve Don’t Make Me Think](/Business/设计/2014-Steve-Don’t%20Make%20Me%20Think.md)
      - [设计之下，搜狐新闻客户端的用户体验设计](/Business/设计/2014-设计之下，搜狐新闻客户端的用户体验设计.md)
    - 金融
      - [投资最重要的事](/Business/金融/投资最重要的事.md)
      - [金融 400 年](/Business/金融/金融%20400%20年.md)
      - [金融的本质](/Business/金融/金融的本质.md)
  - Frontend
    - Android
      - [Gradle Recipes for Android](/Frontend/Android/2016-Gradle%20Recipes%20for%20Android.md)
    - CGDataVis
      - [The Grammar of Graphics 2nd](/Frontend/CGDataVis/2005-The%20Grammar%20of%20Graphics-2nd.md)
      - [Information Visualization Perception for Design](/Frontend/CGDataVis/2012-Information%20Visualization%20Perception%20for%20Design.md)
      - [Data Visualization with D3.js Cookbook](/Frontend/CGDataVis/2013-Data%20Visualization%20with%20D3.js%20Cookbook.md)
      - [The Visualization Handbook](/Frontend/CGDataVis/2014-The%20Visualization%20Handbook.md)
      - [Visualization Analysis & Design](/Frontend/CGDataVis/2014-Visualization%20Analysis%20&%20Design.md)
      - Graphic
        - [冈萨雷斯 数字图像处理 2nd](/Frontend/CGDataVis/Graphic/2003-冈萨雷斯-数字图像处理-2nd.md)
        - [计算机图形学及实用编程技术](/Frontend/CGDataVis/Graphic/2009-计算机图形学及实用编程技术.md)
        - [Three.js 开发指南](/Frontend/CGDataVis/Graphic/2014-Three.js%20开发指南.md)
        - [计算机图形学 3rd](/Frontend/CGDataVis/Graphic/2014-计算机图形学-3rd.md)
    - Web
      - [精通 CSS 高级 Web 标准解决方案](/Frontend/Web/2010-精通%20CSS%20高级%20Web%20标准解决方案.md)
      - [深入浅出NodeJS](/Frontend/Web/2011-深入浅出NodeJS.md)
      - [Mastering HTML and CSS](/Frontend/Web/2012-Mastering%20HTML%20and%20CSS.md)
      - [Apress.Pro.React](/Frontend/Web/2015-Apress.Pro.React.md)
      - [CSS Secrets. Better Solutions to Everyday Web Design Problems](/Frontend/Web/2015-CSS%20Secrets.%20Better%20Solutions%20to%20Everyday%20Web%20Design%20Problems.md)
      - [Cascading Style Sheets Level 2 Revision 2 Specification](/Frontend/Web/2016-Cascading%20Style%20Sheets%20Level%202%20Revision%202%20Specification.md)
      - [State of Vue.js report 2017 by Monterail](/Frontend/Web/2017-State%20of%20Vue.js%20report%202017%20by%20Monterail.md)
      - [于航 深入浅出 WebAssembly](/Frontend/Web/2018-于航-深入浅出%20WebAssembly.md)
  - Infrastructure
    - Cloud
      - [云计算与分布式系统， 从并行处理到物联网](/Infrastructure/Cloud/2011-云计算与分布式系统，%20从并行处理到物联网.md)
    - Database
      - [HBase 权威指南](/Infrastructure/Database/2011-HBase%20权威指南.md)
      - [Redis 入门指南](/Infrastructure/Database/2013-Redis%20入门指南.md)
      - [Redis 设计与实现](/Infrastructure/Database/2013-Redis%20设计与实现.md)
      - [数据库查询优化器的艺术，原理解析与 SQL 性能优化](/Infrastructure/Database/2013-数据库查询优化器的艺术，原理解析与%20SQL%20性能优化.md)
      - [高性能 MySQL 3rd](/Infrastructure/Database/2013-高性能%20MySQL-3rd.md)
      - [Peter Bailis Readings in Database Systems 5th](/Infrastructure/Database/2015-Peter%20Bailis-Readings%20in%20Database%20Systems-5th.md)
      - [MySQL 5.7 Reference Manual](/Infrastructure/Database/2016-MySQL%205.7%20Reference%20Manual.md)
      - [Kleppmann Designing Data Intensive Applications](/Infrastructure/Database/2017-Kleppmann-Designing%20Data%20Intensive%20Applications.md)
      - [MySQL 技术内幕：InnoDB 存储引擎](/Infrastructure/Database/2017-MySQL%20技术内幕：InnoDB%20存储引擎.md)
      - [Mysql Group Replication 官方文档](/Infrastructure/Database/2017-Mysql%20Group%20Replication%20官方文档.md)
      - [Design and Implementation of Scalable, Fully Distributed Web Crawler for a Web Search Engine](/Infrastructure/Database/Design%20and%20Implementation%20of%20Scalable,%20Fully%20Distributed%20Web%20Crawler%20for%20a%20Web%20Search%20Engine.md)
      - [Optimization of Distributed Crawler under Hadoop ](/Infrastructure/Database/Optimization%20of%20Distributed%20Crawler%20under%20Hadoop%20.md)
      - [Research on Detection Algorithm of WEB Crawler](/Infrastructure/Database/Research%20on%20Detection%20Algorithm%20of%20WEB%20Crawler.md)
      - Specials
        - Google
          - [Bigtable: A Distributed Storage System for Structured Data](/Infrastructure/Database/Specials/Google/2006-Bigtable:%20A%20Distributed%20Storage%20System%20for%20Structured%20Data.md)
          - [Spanner: Google’s Globally Distributed Database](/Infrastructure/Database/Specials/Google/2012-Spanner:%20Google’s%20Globally-Distributed%20Database.md)
          - [F1: A Distributed SQL Database That Scales](/Infrastructure/Database/Specials/Google/2013-F1:%20A%20Distributed%20SQL%20Database%20That%20Scales.md)
          - [Google 经典 BigTable, Spanner, F1 论文笔记](/Infrastructure/Database/Specials/Google/Google%20经典%20BigTable,%20Spanner,%20F1%20论文笔记.md)
    - DistributedComputing
      - [Ajay Distributed Computing, Principles, Algorithms, and Systems](/Infrastructure/DistributedComputing/2008-Ajay-Distributed%20Computing,%20Principles,%20Algorithms,%20and%20Systems.md)
      - [分布式计算：原理、算法和系统](/Infrastructure/DistributedComputing/2008-分布式计算：原理、算法和系统.md)
      - [Hadoop 技术内幕 深入理解 MapReduce 架构设计与实现原理](/Infrastructure/DistributedComputing/2013-Hadoop%20技术内幕%20深入理解%20MapReduce%20架构设计与实现原理.md)
      - [Hadoop 技术内幕 深入解析 Hadoop Common 和 HDFS 架构设计与实现原理](/Infrastructure/DistributedComputing/2013-Hadoop%20技术内幕%20深入解析%20Hadoop%20Common%20和%20HDFS%20架构设计与实现原理.md)
      - [Getting Started With Apache Spark](/Infrastructure/DistributedComputing/2015-Getting%20Started%20With%20Apache%20Spark.md)
      - [Manning Hadoop in Practice 2nd](/Infrastructure/DistributedComputing/2015-Manning%20Hadoop%20in%20Practice-2nd.md)
      - [Apache Kylin](/Infrastructure/DistributedComputing/2017-Apache%20Kylin.md)
      - [Akidau Streaming Systems](/Infrastructure/DistributedComputing/2018-Akidau-Streaming%20Systems.md)
      - [Flink 基础教程](/Infrastructure/DistributedComputing/2018-Flink%20基础教程.md)
    - DistributedSystem
      - [Özsu Principles of Distributed Database Systems 3rd](/Infrastructure/DistributedSystem/2011-Özsu-Principles%20of%20Distributed%20Database%20Systems-3rd.md)
      - [七周七并发模型](/Infrastructure/DistributedSystem/2013-七周七并发模型.md)
      - [Concurrent Programming for Scalable Web Architectures](/Infrastructure/DistributedSystem/2015-Concurrent%20Programming%20for%20Scalable%20Web%20Architectures.md)
      - [The Art of Scalability Scalable Web Architecture  2nd](/Infrastructure/DistributedSystem/2015-The%20Art%20of%20Scalability%20Scalable%20Web%20Architecture%20-2nd.md)
      - [Distributed Systems 3rd edition](/Infrastructure/DistributedSystem/2017-Distributed%20Systems-3rd%20edition.md)
      - [Martin Kleppmann Designing Data Intensive Applications The Big Ideas Behind Reliable, Scalable, and Maintainable Systems](/Infrastructure/DistributedSystem/2017-Martin%20Kleppmann-Designing%20Data-Intensive%20Applications%20The%20Big%20Ideas%20Behind%20Reliable,%20Scalable,%20and%20Maintainable%20Systems.md)
    - OS
      - [汤子瀛 计算机操作系统 3rd](/Infrastructure/OS/2007-汤子瀛-计算机操作系统-3rd.md)
      - [CSAPP 2nd](/Infrastructure/OS/2011-CSAPP-2nd.md)
      - [Linux Shell Scripting Cookboos](/Infrastructure/OS/2011-Linux%20Shell%20Scripting%20Cookboos.md)
      - [深入理解计算机系统 2nd](/Infrastructure/OS/2011-深入理解计算机系统-2nd.md)
      - [深入理解计算机系统](/Infrastructure/OS/2011-深入理解计算机系统.md)
      - [How Linux Works What Every Superuser Should Know 2nd](/Infrastructure/OS/2012-How%20Linux%20Works%20What%20Every%20Superuser%20Should%20Know-2nd.md)
      - [陈莉君 Linux 操作系统原理与应用 2nd](/Infrastructure/OS/2012-陈莉君-Linux%20操作系统原理与应用-2nd.md)
      - [Bash Notes For Professionals](/Infrastructure/OS/2014-Bash%20Notes%20For%20Professionals.md)
      - [Operating System Concepts 10th](/Infrastructure/OS/2018-Operating%20System%20Concepts-10th.md)
      - [Jon Stokes Insidethe Machine](/Infrastructure/OS/2019-Jon%20Stokes-Insidethe%20Machine.md)
  - PL
    - Go
      - [Go 语言高级编程](/PL/Go/2017-Go%20语言高级编程.md)
    - Java
      - [Java 问题定位技术 书签版](/PL/Java/2009-Java%20问题定位技术-书签版.md)
      - [Apress.Apache.Tomcat.7](/PL/Java/2011-Apress.Apache.Tomcat.7.md)
      - [Java Concurrency In Practice](/PL/Java/2011-Java%20Concurrency%20In%20Practice.md)
      - [Java 并发编程实战](/PL/Java/2011-Java%20并发编程实战.md)
      - [深入理解 Java 虚拟机：JVM 高级特性与最佳实践](/PL/Java/2011-深入理解%20Java%20虚拟机：JVM%20高级特性与最佳实践.md)
      - [Apache Tomcat 7 Essentials](/PL/Java/2012-Apache%20Tomcat%207%20Essentials.md)
      - [A Little Java A Few Patterns](/PL/Java/2013-A%20Little%20Java%20A%20Few%20Patterns.md)
      - [Java 8 in Action_Lambdas,Streams,and Functional Style Programming](/PL/Java/2014-Java%208%20in%20Action_Lambdas,Streams,and%20Functional-Style%20Programming.md)
      - [Java Performance The Definitive Guide](/PL/Java/2014-Java%20Performance-The%20Definitive%20Guide.md)
      - [Java 并发编程的艺术](/PL/Java/2015-Java%20并发编程的艺术.md)
      - [Norman Netty in Action](/PL/Java/2015-Norman-Netty%20in%20Action.md)
      - [实战 Java 高并发程序设计](/PL/Java/2015-实战%20Java%20高并发程序设计.md)
      - [Java 面试宝典](/PL/Java/2016-Java%20面试宝典.md)
      - [Thinking in Java 4th](/PL/Java/2016-Thinking%20in%20Java-4th.md)
      - [阿里巴巴 Java 开发手册 v1.4.0](/PL/Java/阿里巴巴%20Java%20开发手册-v1.4.0.md)
    - JavaScript
      - [JavaScript 权威指南 6th](/PL/JavaScript/2012-JavaScript%20权威指南-6th.md)
    - Python
      - [Python 性能分析与优化](/PL/Python/2017-Python%20性能分析与优化.md)
      - [Halterman Fundamentals of Python Programming](/PL/Python/2019-Halterman-Fundamentals%20of%20Python%20Programming.md)
    - Rust
      - [The Rust Programming Language 1st](/PL/Rust/2015-The%20Rust%20Programming%20Language-1st.md)
      - [The Rust Programming Language 2nd](/PL/Rust/2017-The%20Rust%20Programming%20Language-2nd.md)
    - Theory
      - [SICP 计算机程序的构造和解释 2nd](/PL/Theory/1996-SICP%20计算机程序的构造和解释-2nd.md)
      - [程序员的自我修养  链接、装载与库](/PL/Theory/2009-程序员的自我修养--链接、装载与库.md)
      - [Tim Stuart Understanding Computation](/PL/Theory/2013-Tim%20Stuart-Understanding%20Computation.md)
      - [Rich Hickey A History of Clojure](/PL/Theory/2020-Rich%20Hickey-A%20History%20of%20Clojure.md)
  - [README en](/README-en.md)
  - Series
    - The New Stack
      - [Applications and Microservices with Docker and Containers](/Series/The%20New%20Stack/2016-Applications%20and%20Microservices%20with%20Docker%20and%20Containers.md)
      - [Automation and Orchestration with Docker and Containers](/Series/The%20New%20Stack/2016-Automation%20and%20Orchestration%20with%20Docker%20and%20Containers.md)
      - [Monitoring and Management with Docker and Containers](/Series/The%20New%20Stack/2016-Monitoring%20and%20Management%20with%20Docker%20and%20Containers.md)
      - [Networking Security and Storage with Docker and Containers](/Series/The%20New%20Stack/2016-Networking%20Security%20and%20Storage%20with%20Docker%20and%20Containers.md)
      - [The Docker and Container Ecosystem](/Series/The%20New%20Stack/2016-The%20Docker%20and%20Container%20Ecosystem.md)
      - [The State Of The Kubernetes Ecosystem](/Series/The%20New%20Stack/2016-The%20State%20Of%20The%20Kubernetes%20Ecosystem.md)
      - [Use Cases For Kubernetes](/Series/The%20New%20Stack/2016-Use%20Cases%20For%20Kubernetes.md)
      - [CI CD with Kubernetes](/Series/The%20New%20Stack/2019-CI%20CD%20with%20Kubernetes.md)
      - [Guide To Cloud Native DevOps](/Series/The%20New%20Stack/2019-Guide%20To%20Cloud%20Native%20DevOps.md)
      - [Guide To Cloud Native Microservices](/Series/The%20New%20Stack/2019-Guide%20To%20Cloud%20Native%20Microservices.md)
      - [Guide To Serverless Technologies](/Series/The%20New%20Stack/2019-Guide%20To%20Serverless%20Technologies.md)
      - [Kubernetes Deployment And Security Patterns](/Series/The%20New%20Stack/2019-Kubernetes%20Deployment%20And%20Security%20Patterns.md)
      - [Kubernetes Solutions Directory](/Series/The%20New%20Stack/2019-Kubernetes%20Solutions%20Directory.md)
  - Specials
    - [吴军 浪潮之巅 完整清晰版](/Specials/2011-吴军-浪潮之巅-完整清晰版.md)

repository: guanqiao/Awesome-CS-Books-and-Digests

repo_name: guanqiao/Awesome-CS-Books-and-Digests


text:
---
name: Feature Request
about: Help us improve by requesting a feature or improvements
---

## Description

A short summary of your feature request or improvements

## User Research

Do you think rest of the users will also get benefited by implementing this? If yes, could you please elaborate on why?

## Comments

license: MIT

repository: kunalmhatre/bundlem

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive

repo_name: kunalmhatre/bundlem


text:
---
hrs_structure:
  division: '3'
  volume: '12'
  title: '29'
  chapter: 531B
  section: 531B-8
type: hrs_section
tags:
  - Property
  - Family
menu:
  hrs:
    identifier: HRS_0531B-0008
    parent: HRS0531B
    name: 531B-8 Right to rely on representations
weight: 55040
title: Right to rely on representations
full_title: 531B-8 Right to rely on representations
---
**[****§531B-8] Right to rely on representations.** (a) Any person signing a funeral service agreement, cremation authorization form, or any other authorization for disposition shall be deemed to warrant the truthfulness of any facts set forth therein, including the identity of the decedent whose remains are to be buried, cremated, or otherwise disposed of, and the party's authority to order the disposition.

(b) A funeral establishment, cemetery, mortuary, or crematory shall have the right to rely on the funeral service agreement, cremation authorization form, or any other authorization form, including the identification of the decedent, and shall have the authority to carry out the instructions of the person or persons whom the funeral establishment, cemetery, mortuary, or crematory reasonably believes to hold the right of disposition.

(c) The funeral establishment, cemetery, mortuary, or crematory shall have no responsibility to verify the identity of the decedent or contact or independently investigate the existence of any person who may have a right of disposition. If there is more than one person in the same priority class pursuant to section 531B-4 and the funeral establishment, cemetery, mortuary, or crematory has no knowledge of any objection by other members of the priority class, it may rely on and act according to the instructions of the first person in the priority class to make funeral and disposition arrangements; provided that no other person in the priority class provides written notice to the funeral establishment, cemetery, mortuary, or crematory of that person's objections. [L 2013, c 17, pt of §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
---
layout: post
title: Welcome to my blog!
---

This blog serves as an outlet for my data science projects and research. The blog might potentially be cross-hosted on a private domain but for now it resides here on github.

Things to do:
* Next you can update your site name, avatar and other options using the _config.yml file in the root of your repository (shown below):

  ![_config.yml]({{ site.baseurl }}/images/config.png)

  The easiest way to make your first post is to edit this one. Go into /_posts/ and update the Hello World markdown file. For more instructions head over to the [Jekyll Now repository](https://github.com/barryclark/jekyll-now) on GitHub.

* Add a theme to blog

* Create a blog post regarding Project Benson, an investigation into dynamic pricing opportunities for the New York Metropolitan Transportation Authority.  Summarize problem statement, data munging, data analysis, and key takeaways. Include a link to the original proposal.

* Previous Projects

* Add CV, links to LinkedIn, github, pictures

* Move to WordPress or Squarespace


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

## [1.1.4](https://github.com/apollo-elements/apollo-elements/compare/@apollo-elements/haunted@1.1.3<EMAIL_ADDRESS>(2021-01-17)

**Note:** Version bump only for package @apollo-elements/haunted

## [1.1.4-alpha.0](https://github.com/apollo-elements/apollo-elements/compare/@apollo-elements/haunted@1.1.3<EMAIL_ADDRESS>(2021-01-17)

**Note:** Version bump only for package @apollo-elements/haunted

## [1.1.3](https://github.com/apollo-elements/apollo-elements/compare/@apollo-elements/haunted@1.1.2<EMAIL_ADDRESS>(2021-01-14)

**Note:** Version bump only for package @apollo-elements/haunted

## [1.1.2](https://github.com/apollo-elements/apollo-elements/compare/@apollo-elements/haunted@1.1.1<EMAIL_ADDRESS>(2021-01-07)

### Bug Fixes

* depend on interfaces package ([90e5974](https://github.com/apollo-elements/apollo-elements/commit/90e5974946f502925aa1d7f1f9fbb1ecbe4302dc))

## [1.1.1](https://github.com/apollo-elements/apollo-elements/compare/@apollo-elements/haunted@1.1.0<EMAIL_ADDRESS>(2021-01-04)

### Bug Fixes

* fix mixin types ([d3f789f](https://github.com/apollo-elements/apollo-elements/commit/d3f789f62cc088505bf7a6f4e390ac37c54ef6c1))

# [1.1.0](https://github.com/apollo-elements/apollo-elements/compare/@apollo-elements/haunted@1.1.0-alpha.2<EMAIL_ADDRESS>(2021-01-04)

### Bug Fixes

* remove .ts sources from packages ([c71057e](https://github.com/apollo-elements/apollo-elements/commit/c71057ee42ae610621113d5da9555f0a8c42d96c))
* **lib:** add graphql as peerDependency ([6804208](https://github.com/apollo-elements/apollo-elements/commit/68042089167222b8ca13895f88077b38e973e186))

# [1.1.0-alpha.2](https://github.com/apollo-elements/apollo-elements/compare/@apollo-elements/haunted@1.1.0-alpha.0<EMAIL_ADDRESS>(2020-12-21)

### Bug Fixes

* **haunted:** update lib ([cc151eb](https://github.com/apollo-elements/apollo-elements/commit/cc151eb9eb7553cbc46f5dc6ea61fe049228d91d))

### Features

* support for TypedDocumentNode ([d39ca4e](https://github.com/apollo-elements/apollo-elements/commit/d39ca4e0094220cfceba97b9bfe59ed078045560))

# [1.1.0-alpha.1](https://github.com/apollo-elements/apollo-elements/compare/@apollo-elements/haunted@1.1.0-alpha.0<EMAIL_ADDRESS>(2020-12-05)

### Features

* support for TypedDocumentNode ([152b4f0](https://github.com/apollo-elements/apollo-elements/commit/152b4f0e66ff22b7aa30c7b926db8291b0cbdfea))

# [1.1.0-alpha.0](https://github.com/apollo-elements/apollo-elements/compare/@apollo-elements/haunted@1.0.0<EMAIL_ADDRESS>(2020-12-04)

### Bug Fixes

* package export maps ([1eaa0ed](https://github.com/apollo-elements/apollo-elements/commit/1eaa0eda5d329b7c7efdf732b63599b912eb8fc8))

### Features

* support TypeScript strict mode ([a8953d0](https://github.com/apollo-elements/apollo-elements/commit/a8953d08d8e050d9ad4e5b9728a7ed44fcc18fa8))

# 1.0.0 (2020-11-22)

### Features

* add haunted support ([36b2648](https://github.com/apollo-elements/apollo-elements/commit/36b2648bf0f4ff096d9d21036fa7805d5909fa1a))

license: ISC

repository: apollo-elements/apollo-elements

branch_name: refs/heads/main

gha_language: TypeScript

gha_license_id: ISC

repo_name: apollo-elements/apollo-elements


text:
***
Change Log
=====

**17.01.15**
* Official pyWSD version 1.0 announced.

**14.01.15**
* Added all-words WSD functionality
* Added disambiguate() for all-words WSD

**05.01.15**:
* Removed old `svm.py`.
* Added Merlin Machine Learning library to support SVM.

**06.11.14**:
* Fixed bugs in original_lesk() and POS checks in simple_lesk()

**25.10.14**:
* Added corpus readers for SemEval-2007 coarse-grain WSD data and SemCor

**29.05.14** (user request):
* Automatically lemmatize `ambiguous_word` parameter because without it being a lemma, `wn.synsets(ambiguous_word)` breaks the system.

**15.05.14** (bugfix):
* Added try-excepts to allow old NLTK Synset properties.

**15.04.14**:

* Changed `Synset` properties to methods adhering to new `NLTK` version (see see http://goo.gl/hO79KO)
* Added N-best results, `pywsd` now outputs ranked list of synsets (possible with normalized scores too), see test_wsd.py

**03.04.14**:
* Added similarity based WSD methods.

repository: alvations/pywsd

gha_language: Python

repo_name: alvations/pywsd


text:
# SQL-Queries-Data-Project
In this project, I used Structured Query Language (SQL) to extract and analyze data stored in a database.
- Wrote SQL queries using PostegreSQL
- Imported Query results to Microsoft Excel and deep on data analysis using advanced formulas and Pivot tables
- Developed awesome graphs in Excel for Digital Music Store Database and summarize key insights for audiences.

repository: VeronikaFG/SQL-Queries-Data-Project

repo_name: VeronikaFG/SQL-Queries-Data-Project


text:
# Proference Motivation Doc

## Context

### Related works

- [MagicHaskeller](http://nautilus.cs.miyazaki-u.ac.jp/~skata/MagicHaskeller.html)
- [djinn](https://hackage.haskell.org/package/djinn)
- [exference](https://hackage.haskell.org/package/exference)
- ...

## Definitions

XYZZY: Tests, signatures, functions and data types to use, literals, specific compositions...

## High-level goals

### Interactive notepad-like design.

- Ideally linear progression of small increments.

- Focus on a single increment a time.

- Rely on refactoring tools to factor the sketch once satisfied.

### Work on alternatives concurrently.

Share resources between them according to likelihood of success.

For example, heuristics of resolution can be:
- Working from signature to implementation (djinn, exference)
- Working from test cases to implementation (MagicHaskeller)
- Likelihood of implementation given prior patterns in codebase
- ...

### Provide insight, present meaningful choices.

The algorithm is not omnipotent. The user should be able to get feedback on search state, and control paths.
For example, the user can instruct the prune obviously bad search spaces, or encourage searching a promising path with higher priority.

### Commit to final resolution as late as possible.

XYZZYs relating to an increment can be input separately, but are resolved together.
For example, ambiguity in tests might be resolved by further constraints, or vice-versa.

## Breadcrumbs

repository: TreeTide/proference

repo_name: TreeTide/proference


text:
# Contributing to B E E F Y

## Opening an Issue

Have a great idea for a new feature? Or a bug you'd like to be quashed? Report it as an issue!
Make sure you include the following information, in the case of bugs:

1. The version of beefy you're running.
2. The version of node you're running.
3. What happened, and how it differed from your expectations.
4. Ideally, a reproducible test case.

## Developing: Getting Started

* Make sure you have Node >= 0.10 installed. You can grab that [here](http://nodejs.org/).
* Clone the repo from Github.
* In your checkout, run `npm install`.
* Run `npm test`. If this succeeds, you should see `# ok` as one of the last lines of output.
* To lint, run `./node_modules/.bin/jsl <file>`. The linter runs as part of the test suite.
* For code coverage, run `npm run test-cov`.

## Making a Pull Request

Make sure you've added **tests** and **documentation**, where appropriate, and that the former
is passing.

If you have **any** questions, drop by `#pdxnode` on irc.freenode.net
and mention that you're working on beefy. There are many helpful folks in there! If you're not
on IRC, feel free to email [<EMAIL_ADDRESS>with your questions.

## finally...

Thanks for contributing to Beefy!

license: MIT,ISC

detected_licenses: MIT ISC


text:
[Home](./index.md) > [decentraland-ecs](./decentraland-ecs.md) > [Path2](./decentraland-ecs.path2.md)

## Path2 class

Represents a 2D path made up of multiple 2D points

Signature:

```typescript
export declare class Path2
```

## Constructors

|  Constructor | Modifiers | Description |
|  --- | --- | --- |
|  [(constructor)(x, y)](./decentraland-ecs.path2.(constructor).md) |  | Creates a Path2 object from the starting 2D coordinates x and y. |

## Properties

|  Property | Modifiers | Type | Description |
|  --- | --- | --- | --- |
|  [closed](./decentraland-ecs.path2.closed.md) |  | boolean | If the path start and end point are the same |

## Methods

|  Method | Modifiers | Description |
|  --- | --- | --- |
|  [addArcTo(midX, midY, endX, endY, numberOfSegments)](./decentraland-ecs.path2.addarcto.md) |  | Adds \_numberOfSegments\_ segments according to the arc definition (middle point coordinates, end point coordinates, the arc start point being the current Path2 last point) to the current Path2. |
|  [addLineTo(x, y)](./decentraland-ecs.path2.addlineto.md) |  | Adds a new segment until the given coordinates (x, y) to the current Path2. |
|  [close()](./decentraland-ecs.path2.close.md) |  | Closes the Path2. |
|  [getPointAtLengthPosition(normalizedLengthPosition)](./decentraland-ecs.path2.getpointatlengthposition.md) |  | Retreives the point at the distance aways from the starting point |
|  [getPoints()](./decentraland-ecs.path2.getpoints.md) |  | Gets the points which construct the path |
|  [length()](./decentraland-ecs.path2.length.md) |  | Gets the sum of the distance between each sequential point in the path |
|  [StartingAt(x, y)](./decentraland-ecs.path2.startingat.md) | static | Creates a new path starting from an x and y position |

repository: LeonardoVenezia/decentraland-Shoes-Shop

repo_name: LeonardoVenezia/decentraland-Shoes-Shop


text:
---
id: inbound_roaming
title: Inbound Roaming
hide_title: true
---

# Inbound Roaming

Inbound Roaming allows a Magma operator to provide service for subscribers
belonging to other operators (roaming subscribers)

Inbound Roaming requires Magma operator to reach agreements with
other operators to have direct connectivity to their HSS through `S6a`
(diameter) and PGW through `S8` (gtp) interfaces. VPN is suggested to reach
those roaming services but is out of scope of Magma.

At the bottom of this document you have
[configuration example](#configuration-example)

TEID allocation is described on
[Technical Reference](https://magma.github.io/magma/docs/lte/dev_teid_allocation)
section.

## Architecture

Currently, we support two Architectures:

- **Local Non-Federated + Roaming**: where local subscribers are stored in
  SubscriberDB and roaming subscribers use a remote Federated Gateway to reach
  HSS/PGW.
- **Local Federated + Roaming**: where local Subscribers use local Federated
  Gateway to reach HSS/PCRF/OCS and roaming Subscribers use a remote Federated
  Gateway to reach HSS/PGW.

Any roaming architecture will be composed of an LTE Federated Network and Feg
Network that will serve the local subscribers. Then we will have as many extra
FEG Network as roaming agreements.

The example in the picture blow shows a possible architecture for a
Local Non-Federated + Roaming case (one roaming agreement). As you can see in
the picture below, VPN is suggested to reach to the user plane at the remote
PGW.

![Magma events table](assets/feg/inbound_roaming_architecture_non_federated.png?raw=true "Non-Federated Inbound Roaming")

Other configurations like SubscriberDB with PCRF/OCS to handle local
subscribers may also work but are not tested yet.

Configurations with SubscriberDB, local HSS and remote HSS all at the same
time is not supported yet.

The following is a logic diagram of Neutral Host architecture we
use on Inbound Roaming to be able to route the request properly. Note that
in this diagram we add the Optional Local FeG. In case you are using
subscriberDB for your local subscribers, you will not need that FeG Gateway,
but you will still need the Neutral Host Network.

```mermaid
graph LR

AGW_G --Any_PLMN--> Orc8r
Orc8r --PLMN1--> FeG_Gateway_1
Orc8r --PLMN2--> FeG_Gateway_2
Orc8r --PLMN3--> FeG_Gateway_3
Optional_FeG_gateway --Other_PLMN--> Local_HSS
FeG_Gateway_1 --> HSS_1
FeG_Gateway_2 --> HSS_2
FeG_Gateway_3 --> HSS_3

subgraph AGW Network
AGW_G
end

subgraph Neutral_Host_Network
Orc8r & Optional_FeG_gateway

end

subgraph Roaming_FeG_Network_1
FeG_Gateway_1
end

subgraph Roaming_FeG_Network_2
FeG_Gateway_2
end

subgraph Roaming_FeG_Network_3
FeG_Gateway_3
end
```

## Prerequisites

Before starting to configure roaming setup, first you need to bring up a
setup to handle your own/local subscribers. So before configuring Inbound
Roaming you need:

- Install [Or8cr](https://magma.github.io/magma/docs/orc8r/architecture_overview),
- Install [Federation Gateway](https://magma.github.io/magma/docs/feg/deploy_intro) and,
- Install [Access Gateway](https://magma.github.io/magma/docs/lte/setup_deb).
- Create a Federate Deployment (see [below](#Create a Federated Deployment)).
- Make sure your setup is able to serve calls with your local subscribers

Once you are done you should either:

- Local Non-Federated case:  `a Federated LTE Network with an LTE Gateway (AGW)` + `a Federation Network WITHOUT Federation Gateway (FeG)`
- Local Federated case: `a Federated LTE Network with an LTE Gateway (AGW)`+
  `a Federation Network WITH Federation Gateway (FeG)`

We will refer to them as `local` Networks and Gateways to differentiate them
from the `roaming` Networks and Gateways we will create in the next step.

### Create a Federated Deployment

As mentioned, Inbound Roaming requires of a FeG gateway to reach the roaming
network. That is why Federated Deployment is required. Please, configure it
using this guide for [Federated Deployment](https://magma.github.io/magma/docs/feg/federated_FWA_setup_guide).

All architectures requiere a Local FeG Network to exist. However depending on
your architecture, you may not need to create a local FeG Gateway inside that
FeG Network. Please check the table below which indicates what **gateways**
are required depending on the architecture

| Network Type ->       | `feg` roaming | `feg` local | `feg_lte` (AGW) |
| :-------------------: | :-----------: | :----------:| :--------------:|
| Local - Non Federated | Yes           | No          | Yes             |
| Local - Federated     | Yes           | Yes         | Yes             |

For both, Federated and Non-Federated mode, on `lte_feg` network under `epc`
you should set `hss_relay_enabled` to `true`. Selection of HSS or
subscriberDb will be done by Inbound Roaming mapping configuration.

In case you are not using PCRF and OCS, then your
not need to create a FeG Gateway from the previous gide on your Federated
Deployment. Also remember in your Federated LTE network, under `epc`, you
will have to set `gx_gy_relay_enabled` to `false`, so the request are sent to
internal policy entity, not to the PCRF or OCS.

## Inbound Roaming configuration

The following instructions use Orc8r Swagger API to configure Inbound Roaming.
You can do the same using Swagger API or NMS JSON editor.

In these instructions we will mainly use GET and PUT methods to read and write
from Swagger. We will use GET to see the content of Network/Gateway,
we will copy and paste that into the result of GET into the PUT method to
modify parameters.

Below are the steps to add Inbound Roaming to your current setup:

- Create roaming Federated Networks and Gateways.
- Configure local Access Gateway Network routing based on PLMN.
- Configure local Federation Network routing based on PLMN.
- Configure roaming Federation Network served networks
- Configure FeG Gateways
- Check connectivity

### 1. Create Roaming Federated Networks and Federated Gateways

Inbound Roaming needs as many FeG Networks as roaming agreements. Don't
forget to create a Federated Gateway per FeG Network.

Roaming FeG Networks do not need to serve any Federated LTE Network (only the
FeG Network created on Pre Requisites needs to serve a Federated LTE Network)

Those roaming Federated Gateways will need `S6a` and `S8` interfaces
configured (make sure you have the other operators HSS and PGW
parameters). To configure those interfaces go to **Swagger API**:

- Go to`Federation Gateways` GET method `Get a specific
  federation gateway` and search the configuration for one of those roaming
  FeG Networks.
- Copy/paste the response into the PUT method `Update an entire federation
  gateway record`
- Edit the `6a` and `S8` fields (check the example from the GET method to
  see any missing parameter)
- Hit Execute (check no errors are show on the Swagger Responses)
- Run the GET method again to see the changes.

Note that you need a routable IP to the roaming HSS and PGW to configure those
interfaces.

### 2. Configure Local Access Gateway Network routing

When a request gets to Access Gateway, this will have to be routed to
the proper call flow to either use `SubscriberDB` or `S6a/S5` or`S6a/S8`.
based on subscriber PLMN.

To enable that routing you will have to configure it in your local Access
Gateway Network we created in Pre Requisites. On **Swagger API**:

- Go to `Federated LTE Networks` and search using GET method `Describe a
  federated LTE network` your local (non roaming) Federated LTE Network
- Copy/paste the response into PUT method `Update an entire Federated LTE
  network`
- Find the key `federation`. If you completed Pre Requisites properly, you
  should have `feg_network_id` pointing to your FeG Network.
- Add the routing dictionary following the example below, adding an entry per
each PLMN.

```text
  "federation": {
    "federated_modes_mapping": {
      "enabled": true,
      "mapping": [
        {
          "apn": "",
          "imsi_range": "",
          "mode": "local_subscriber",
          "plmn": "123456"
        },
        {
          "apn": "",
          "imsi_range": "",
          "mode": "s8_subscriber",
          "plmn": "9999"
        }
      ]
    },
    "feg_network_id": "example_feg_network"
  },
```

To configure that key properly:

- Field `mode` will indicate the path the subscriber will take:
    - `local_subscriber` for PLMNs served by your own SubscriberDB/HSS.
    - `s8_subscriber` for PLMNs served by roam HSS (`S6a`) and roam PGW (`S8`).
    - Any other PLMN not configured here will be defaulted to local HSS (`S6a`).
- You can leave `apn` and `imsi_range` blank since it is not supported yet
- Add the routing dictionary following the example, adding an entry per each
PLMN.
- Note `hss_relay_enabled` must be enabled. The decision to send it to HSS or
  not will be taken by `federated_modes_mapping`. If you disable, s8_subscribers
  will not be sent to the FeG to get the HSS.

- Flag `gx_gy_relay_enabled` can be enabled or disabled depending on if your
  network works with local policy db or with OCS and PCRF (gx/gy). If your
  local subscribers authenticate with HSS but use GX/GY, then you will have to
  leave it as `True`.

### 3. Configure Local Federation Network routing

When a request gets to the Orc8r, this will have to be routed to the proper
FeG Network which serves that PLMN.

To enable that routing you will have to configure it in your local FeG Network
we created in Pre Requisites. On **Swagger API**:

- Go to `Federation Networks` and search using GET method `Describe a
  federation network` your local (non roaming) FeG Network
- Copy/paste the response into PUT method `Update an entire federation network`
- Modify/add the `nh_routes` (see the example on Swagger API if it is
  missing from your configuration). On the map match the PLMN, and the name
  of the roam FeG Network. Note that these are names of FeG Networks,
  not FeG Gateways.

```text
    "nh_routes": {
      "00102": "inbound_feg",
      "9999": "feg_roaming_network_1"
    },
```

- Hit Execute (check no errors are show on the Swagger Responses)
- Run the GET method again to see the changes.

### 4. Configure Roaming Federation Network served networks

Roaming Federation Networks will need a last configuration in order to match
them with their serving Local Federation Network. To do that, add to the
Roaming Federation Networks configuration the following key

```text
    "served_nh_ids": [
      "example_feg_network"
    ],
```

That means that the Inbound FeG Network will be served by the local network
(in this case called `example_feg_network`)

### 5. Configure Roaming FeG Gateway

Configure Roaming FeG gateway serving roaming subscribers, but just configure
`s6a` and `s8`. Configure local GTP port to match with your PGW GTP-U port.
`apn_operator_sufix` is optional and will just add a suffix to the APN sent by
the UE.

```text
   "s8": {
      "apn_operator_suffix": ".operator.com",
      "local_address": "foo.bar.com:5555",
      "pgw_address": "foo.bar.com:5555"
    },
```

Note you don't need to define the local IP, you can just use :port
`"local_address": ":5555"`

### 6. Check connectivity

- From Access Gateway make sure your Access Gateway is able to reach PGW-U
  IP.

```bash
ping -I sgi_interface pgw_u_ip
```

- Fom Federated Gateway make sure you can reach PGW-C IP and test your
Federated Gateway can reach PGW using this command

```bash
$ cd /var/opt/magma/docker
$ sudo docker compose exec s8_proxy /var/opt/magma/bin/s8_cli cs -server

<IP_ADDRESS>:2123<PHONE_NUMBER>12345
# where <IP_ADDRESS>:2123 is the ip and port of the PGW-C
# where<PHONE_NUMBER>12345 is a valid imsi (if you use a not valid imsi
# you can still check the connectivity, but you will get a GTP error back
# from PGW
# Add -use_builtincli flag if you don't have a FeG setup properly yet
```

## Test and troubleshooting

It is recommendable that before running the tests, enable some extra
logging capabilities in both Access Gateway, and Federated Gateway to
trace the call.

For better details in Access Gateway logs:

- Enable `log_level: DEBUG` in `mme.yml` and `subscriberdb.yml`
- Enable `print_grpc_payload: True` on `subscriberdb.yml`
- Restart magma, so the changes are taken
- See the logs using `sudo journalctl -fu magma@mme` or sudo `journalctl -fu
  magma@subscriberdb`

For better details Federated Gateway logs:

- Add GRPC printing in the following services  `s6a_proxy`,
  `s8_proxy` adding `MAGMA_PRINT_GRPC_PAYLOAD: 1`. For example for s6a_proxy

```yaml
  s6a_proxy:
    <<: *goservice
    container_name: s6a_proxy
    command: envdir /var/opt/magma/envdir /var/opt/magma/bin/s6a_proxy -logtostderr=true -v=0
    environment:
      MAGMA_PRINT_GRPC_PAYLOAD: 1
```

- Restart docker process, so the vars are taken `sudo docker compose down` and
  `sudo docker compose --compatibility up -d`
- Display the logs using for example`sudo docker compose logs -f s8_proxy`

### Test with s6a_cli and s8_cli

FeG has a couple of clients to run an HSS Authentication Request (s6a) and
Create Session Request (s8) without the need of having a UE. You can run them
either on FeG or AGW.

- Run From FeG

```bash
# Use FeG s6a_proxy
sudo docker compose exec s8_proxy /var/opt/magma/bin/s6a_cli air -remote_s6a<PHONE_NUMBER>00810
# Use s6a_porxy that runs on the cli
sudo docker compose exec s8_proxy /var/opt/magma/bin/s6a_cli air -use_builtincli false  -remote_s6a<PHONE_NUMBER>00810

# use FeG s8_proxy
sudo docker compose exec s8_proxy /var/opt/magma/bin/s8_cli cs -server <IP_ADDRESS>:2123 -delete 3
# use s8_proxy that runs on the cli
sudo docker compose exec s8_proxy /var/opt/magma/bin/s8_cli cs -server <IP_ADDRESS>:2123 -use_builtincli false -delete 3
```

- Run from AGW

```bash
# Extract the binaries from docker container from FeG, and move them to AGW
sudo docker cp s6a_proxy:/var/opt/magma/bin/s6a_cli .
sudo docker cp s8_proxy:/var/opt/magma/bin/s8_cli .
```

```bash
# Execute from AGW
./s6a_cli air -remote_s6a<PHONE_NUMBER>00810
./s8_cli cs -server <IP_ADDRESS>:2123 -delete 3 -apn inet -remote_s8<PHONE_NUMBER>00810
```

## Configuration example

Attached you can find the configuration that handle local subscribers with
both subscriber db and HSS and roaming subscribers:

- PLMN 88888: uses subscriber DB to authenticate and Gx/Gy for accounting.
  That is why we have `gx_gy_relay_enabled` as True. Those subscribers are
  never sent to the FeG.
- PLMN 00102: MME sends those subscribers to be authenticated through the FeG.
  When the request reaches Orc8r (in Feg Relay service) and using `nh_routes`
  configured on the local FeG network, those subscribers are forwarded to
  `inbound_feg` network
- Rest of PLMN: MME forwards any other PLMN to be authenticated through the
  FeG. In the orc8r they are forwarded to the local FeG network `terravm_feg_network`

[[inbound_roaming_sample.zip]](assets/feg/inbound_roaming_sample.zip)

repository: magma/magma

gha_license_id: NOASSERTION

repo_name: magma/magma


text:
# Executing the function for debugging

The function is run on a timer, but can be executed manually when debugging with the following command:

```
curl -v -X POST -d "{}" -H "content-type: application/json" http://localhost:7071/admin/functions/CheckNistFeed
```

gha_language: C#


text:
# Graphs
* A graph is a non-linear data structure that can be looked at as a collection of vertices (or nodes) potentially connected by line segments named edges.

![](https://www.geeksforgeeks.org/wp-content/uploads/undirectedgraph.png)

## Graphs applications:
* used to visually illustrate relationships in the data.
* Electrical Engineering: used in designing of circuit connections
* Google Search
* Google Maps: various locations are represented as vertices or nodes and the roads are represented as edges
* GPS
* social media
  > Find more application of Graphs [Here](https://www.javatpoint.com/graph-theory-applications)

## Challenge
* Implementing a Graph represented as an adjacency list.

## Approach & Efficiency
* Adjacency List:
 - It represents a graph as an array of linked lists.
 - The index of the array represents a vertex.
 - Each element in its linked list represents the other vertices that form an edge with the vertex.
* Efficiency:
  - For time: O(1)
    1. AddNode(): O(1)
    2. AddEdge(): O(1)
    3. GetNodes(): O(1)
    4. Size(): O(1)
  - For space: O(n+m)
    1. AddNode(): O(n) : n: number of Nodes
    2. AddEdge(): O(m) : m: number of edges
    3. GetNodes(): O(1)
    4. Size(): O(1)

## API
* AddNode():
  - Adds a new node to the graph
  - Takes in the value of that node
  - Returns the added node
* AddEdge():
 - Adds a new edge between two nodes in the graph
 - Include the ability to have a “weight”
 - Takes in the two nodes to be connected by the edge
 - Both nodes should already be in the Graph
* GetNodes()
 - Returns all of the nodes in the graph as a collection (set, list, or similar)
 - GetNeighbors()
 - Returns a collection of edges connected to the given node
 - Takes in a given node
 - Include the weight of the connection in the returned collection
* Size():
 - Returns the total number of nodes in the graph

## Testing:
* `npm test graph.test`
* Code Link: [Here](./graph.js)


text:
# Mapping

Defines the rule set to be used to determine if entries should be considered as a match.

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**scope** | **str** | The scope for this mapping. |
**code** | **str** | The code for this mapping. |
**name** | **str** | The mapping name |
**reconciliation_type** | **str** | What type of reconciliation this mapping is for |
**rules** | [**list[MappingRule]**](MappingRule.md) | The rules in this mapping, keyed by the left field/property name | [optional]

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

repository: finbourne/lusid-sdk-python

repo_name: finbourne/lusid-sdk-python


text:
# Piraeus Operator

Deploys the [Piraeus Operator](https://github.com/piraeusdatastore/piraeus-operator) which deploys and manages a simple
and resilient storage solution for Kubernetes.

The main deployment method for Piraeus Operator switched to [`kustomize`](../../docs/tutorial)
in release `v2.0.0`. This chart is intended for users who want to continue using Helm.

This chart **only** configures the Operator, but does not create the `LinstorCluster` resource creating the actual
storage system. Refer to the existing [tutorials](../../docs/tutorial)
and [how-to guides](../../docs/how-to).

## Deploying Piraeus Operator

To deploy Piraeus Operator with Helm, clone this repository and deploy the chart:

```
$ git clone --branch v2 https://github.com/piraeusdatastore/piraeus-operator
$ cd piraeus-operator
$ helm install piraeus-operator charts/piraeus-operator --create-namespace -n piraeus-datastore
```

Follow the instructions printed by Helm to create your storage cluster:

```
$ kubectl apply -f - <<EOF
apiVersion: piraeus.io/v1
kind: LinstorCluster
metadata:
  name: linstorcluster
spec: {}
EOF
```

Check out our [documentation](../../docs) for more information.

repository: piraeusdatastore/piraeus-operator

gha_language: Go

repo_name: piraeusdatastore/piraeus-operator


text:
---
layout: post
permalink: blog/blog18/
categories: [Data Science]
---

![How to optimize your Jupyter Notebook](https://www.freecodecamp.org/news/content/images/size/w2000/2019/08/1_m87_Htb_9Pstq0UcvNJ49w.png)
(Source: https://gdcoder.com/how-to-create-and-add-a-conda-environment-as-jupyter-kernel/)

<!--end_excerpt-->

# How to optimize your Jupyter Notebook

### Introduction

Jupyter Notebook is nowadays probably the most used environment for solving Machine Learning/Data Science tasks in Python.

Jupyter Notebook is a client-server application used for running notebook documents in the browser. Notebook documents are documents able to contain both code and rich text elements such as paragraphs, equations, etc...

In this article, I will walk you through some simple tricks on how to improve your experience with Jupyter Notebook. We will start from useful shortcuts and we will end up adding themes, automatically generated table of contents etc...

### Shortcuts

Shortcuts can be really useful to speed up writing your code, I will now walk you through some of the shortcuts I found most useful to use in Jupyter.

There are two possible way to interact with Jupyter Notebook: Command Mode and Edit Mode. Some shortcuts works only on one mode or another while others are common to both modes.

Some shortcuts which are common in both modes are:

-   **Ctrl + Enter** : to run all the selected cells
-   **Shift + Enter** : run the current cell and move the next one
-   **Ctrl + s** : save notebook

In order to enter Jupyter command mode, we need to press Esc and then any of the following commands:

-   **H** : show all the shortcuts available in Jupyter Notebook
-   **Shift + Up/Down Arrow** : to select multiple notebook cells at the same time (pressing enter after selecting multiple cells, will make run all of them!)
-   **A** : insert a new cell above
-   **B** : insert a new cell below
-   **X** : cut the selected cells
-   **Z** : undo the deletion of a cell
-   **Y** : change the type of cell to Code
-   **M** : change the type of cell to Markdown
-   **Space** : scroll notebook down
-   **Shift + Space** : scroll notebook up

In order to instead enter Jupyter edit mode, we need to press Enter and successively any of the following commands:

-   **Tab** : code competition suggestions
-   **Ctrl + ]** : indent code
-   **Ctrl + [** : dedent code
-   **Ctrl + z** : undo
-   **Ctrl + y** : redo
-   **Ctrl + a** : select all
-   **Ctrl + Home** : move cursor to cell start
-   **Ctrl + End** : move cursor to the end of the cell
-   **Ctrl + Left** : move cursor one word left
-   **Ctrl + Right** : move cursor one word right

Shell commands and Packages installation
----------------------------------------

Not many users are aware of this, but it is possible to run shell commands in a Jupyter notebook cell by adding an exclamation mark at the beginning of the cell. For example, running a cell with **!ls** will return all the items in the current working directory and running a cell with **!pwd** will instead print out the current directory file-path.

This same trick, can also be applied to install Python packages in Jupyter notebook.

```
!pip install numpy
```

### Jupyter Themes

If you are interested in changing how your Jupyter notebook looks like, it is possible to install a package with a collection of different themes. The default Jupyter theme looks like the one in Figure 1, in Figure 2 you will see how we will be able to personalise it's aspect.

![](https://www.freecodecamp.org/news/content/images/2019/08/2-2.PNG)

Figure 1: Default Jupyter Notebook Theme

We can install our package, directly in the notebook used the trick I showed you in the previous section:

```
!pip install jupyterthemes
```

We can the run the following command to list the names of all the available themes:

```
!jt -l

# Cell output:
# Available Themes:
#   chesterish
#   grade3
#   gruvboxd
#   gruvboxl
#   monokai
#   oceans16
#   onedork
#   solarizedd
#   solarizedl
```

Finally, we can choose a theme using the following command (in this example I decided to use the solarized1 theme):

```
!jt -t solarizedl
```

Once ran this command and refreshed the page, our notebook should like like the one in Figure 2.

![](https://www.freecodecamp.org/news/content/images/2019/08/1-1.PNG)

Figure 2: Solarized1 notebook Theme

In case you wish anytime to come back to the original Jupyter notebook theme, you can just run the following command and refresh your page.

```
!jt -r
```

### Jupyter Notebook Extensions

Notebook extensions can be used to enhance user experience offering a wide variety of personalizations techniques.

In this example, I will be using the *nbextensions* library in order to install all the necessary widgets (this time I suggest you to first install the packages through terminal and then open the Jupyter notebook). This library makes use of different Javascript models in order to enrich the notebook frontend.

```
! pip install jupyter_contrib_nbextensions
! jupyter contrib nbextension install --system
```

Once *nbextensions *is installed you will notice that there is an extra tab on your Jupyter notebook homepage (Figure 3).

![](https://www.freecodecamp.org/news/content/images/2019/08/image-128.png)

Figure 3: Adding *nbextensions *to Jupyter notebook

By clicking on the Nbextensions tab, we will be provided with a list of available widgets. In my case, I decided to enable the ones shown in Figure 4.

![](https://www.freecodecamp.org/news/content/images/2019/08/image-129.png)

Figure 4: *nbextensions widgets options*

Some of my favourite extensions are:

1.  **Table of Contents**

Auto-generate a table of contents from markdown headings (Figure 5).

![](https://www.freecodecamp.org/news/content/images/2019/08/ezgif.com-optimize-1.gif)

Figure 5: Table of Contents

2\. **Snippets**

Sample codes to load common libraries and create sample plots which you can use as starting point for your data analysis (Figure 6).

![](https://www.freecodecamp.org/news/content/images/2019/08/snippets.gif)

Figure 6: Snippets

3\. **Hinterland**

Code autocompletion for Jupyter Notebooks (Figure 7).

![](https://www.freecodecamp.org/news/content/images/2019/08/completition.gif)

Figure 7: Code autocompletion

The *nbextensions* library provides many other extensions apart for these mention three, I encourage you to experiment and test any-other which can be of interest for you!

### Markdown Options

By default, the last output in a Jupyter Notebook cell is the only one that gets printed. If instead we want to automatically print all the commands without having to use *print()*, we can add the following lines of code at the beginning of the notebook.

```
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"
```

Additionally, it is possible to write LaTex in a Markdown cell by enclosing the text between dollar signs ($).

### Notebook Slides

It is possible to create a slideshow presentation of a Jupyter Notebook by going to **View -> Cell Toolbar -> Slideshow **and then selecting the slides configuration for each cell in the notebook.

Finally, going to the terminal and typing the following commands the slideshow will be created.

```
pip install jupyter_contrib_nbextensions

# and successively:

jupyter nbconvert my_notebook_name.ipynb --to slides --post serve
```

![](https://www.freecodecamp.org/news/content/images/2019/08/ezgif.com-optimize--1-.gif)

### Magic

Magics are commands which can be used to perform specific commands. Some examples are: inline plotting, printing the execution time of a cell, printing the memory consumption of running a cell, etc...

Magic commands which starts with just one *%* apply their functionality just for one single line of a cell (where the command is placed). Magic commands which instead starts with two *%%* are applied to the whole cell.

It is possible to print out all the available magic commands by using the following command:

```
%lsmagic
```

gha_language: HTML


text:
# TradeEngine

Very tiny example of an event-sourcing application, shamelessly taken from [AxonTrader](https://github.com/AxonFramework/Axon-trader).

To run the benchmark, just do the following:

    bundle install
    ruby benchmark.rb

You must have MongoDB installed in order to do the benchmark.

## Results

On my 2010 MacBook Pro (2.66 GHz Intel Core i7, 8GB DDR3 RAM):

- Ruby 1.9.3 - 575 commands/sec or 1.7 ms/command
- Ruby 2.0.0 - 496 commands/sec or 2.0 ms/command
- JRuby 1.7.4 - 396 commands/sec or 2.7 ms/command

  This should be faster in theory, but between JRuby's warmup time and the context switching
  done by the current thread pool implementation, it's not so hot. This will be fixed by
  switching to a busy-spin wait strategy and by adding a warmup to the benchmark.

  I'm also not sure of the performance of Marshal on JRuby (or MRI for that matter).

- JRuby 1.7.4 w/ busy-spin + warmup + JVM tweaks - 777 commands/sec or 1.3 ms/command

- Rubinius 22c5fbca - 326 commands/ec or 3.1 ms/command

  I'm not sure what's going on with rbx-head. I get a ton of concurrency errors due to events with a
  duplicate aggregate identifier and sequence number being appended to the event store. It seems as
  if the random number generator on rbx might be broken? Otherwise I have no explanation for this
  yet.

repository: alexaitken/synapse

repo_name: alexaitken/synapse


text:
---
layout:     post
title:      "Leetcode (75) Sort Series"
category:   Leetcode
tags:		Leetcode DFS
---

* content
{:toc}

Leetcode Sort Series

## Leetcode 75. Sort Colors

* [Leetcode 75. Sort Colors](https://leetcode.com/problems/sort-colors/#/description)

Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

```cpp
class Solution {
public:
    void sortColors(vector<int>& nums) {
        int zero=0, two=nums.size()-1;
        for (int i=0; i<=two;) {
            if (nums[i]==0) swap(nums[i++], nums[zero++]);
            else if (nums[i]==2)    swap(nums[i], nums[two--]);
            else    i++;
        }
    }
};
```


text:
# fslab website

Static website generated with :heart:, [fornax](https://github.com/ionide/Fornax), and [fsdocs](https://github.com/fsprojects/FSharp.Formatting)

This [website](https://fslab.org/) demonstrates the aims of the fslab organisation as an incubation space for data science projects in F# and .NET and acts as a source of high quality learning material for any kind of skill level.

<!-- TOC -->

- [Add a project to the packages site](#add-a-project-to-the-packages-site)
- [Add a tutorial, guide, or blogpost](#add-a-tutorial-guide-or-blogpost)
- [Develop](#develop)
    - [Prerequisites](#prerequisites)
    - [Technology used](#technology-used)

<!-- /TOC -->

## Add a project to the packages site

The [packages site](https://fslab.org/packages.html) is used to aggregate fslab-endorsed data science packages in one place.

The main goal of fslab is to streamline the datascience environment of F#.

In a first step we want to collect and foster open source datascience packages and create a save haven for F# open source maintainers and developers

We want to encourage interaction between these libraries to move forward together,
as well as prevent fslab from becoming just an address to dump a project url for easy promotion. Therefore, while we don't want to set up strict requirements - especially in this critical first phase of fslab -
we kindly ask you to meet at least **one of the following requirements** are with your package:

- 1. Additionally to the package documentation itself, **tutorials and guides** on how to get started with and interact with other fslab packages will be included at the time of joining the list. See the [next chapter](#add-a-tutorial-guide-or-blogpost) on how to do that.

- 2. The github repository that holds the source code of the package will **move to the fslab github organization** (with no changes to repo access besides access for fslab admins). This increases the weight of fslab as a center of gravity for open source F# developers and would be the best choice for projects that are in need for new maintainers.

- 3. The **documentation** of the project will be changed or created in the [**fslab documentation theme**](). This ensures fostering a certain fslab 'brand awareness'

To add a package to the endorsed list, follow these steps:

1. Create new [add-package issue](https://github.com/fslaborg/fslaborg.github.io/issues/new/choose) by filling the issue template.

2. Create the `<YOUR-PACKAGE-NAME.md` file in the `src/content/datascience-packages/` folder, which will contain the metadata about the package that is used to generate the card for it on the page.

3. Add the markdown frontmatter (starting on the very first line). Replace the `<>` placeholders with the actual correct information about your package:

    ```
    ---
    package-name: <The name of your package>
    package-logo: <link to your logo>
    package-nuget-link: <https://www.nuget.org/packages/your-package/ or other nuget source>
    package-github-link: <https://www.github.com/your-handle/your-project>
    package-documentation-link: <link to the documentation of your package>
    package-description: <short and concise description of the package>
    #package-posts-link: optional
    package-tags: <(WIP)tags to categorize your package>
    ---
    ```

4. below the frontmatter, add any kind of markdown content that will be rendered as an expandable `Read more` section. You can use the full markdown goodness here, and code snippets indicated as fsharp will get some syntax highlighting.

5. File a PR referencing the issue you created in step 1.

## Add a tutorial, guide, or blogpost

The [tutorials page](https://fslab.org/tutorials.html) contains links to a collection of tutorials in the following categories:

- `fsharp`:
    Introductory articles on F#, assuming no prior knowledge in programming and F#/.NET. There should also be a link collection to other high quality sources on those topics.

- `datascience`:
    Introduction to datascience in general and using F# for it specifically. Beginner and intermediate content on how to perform common datascience tasks with fslab-endorsed packages.

- `advanced`
    Deep dives on advanced topics, performing complex tasks, insights on how packages perform together, etc. More of a blog-post-style content.

To add tutorial content, follow these steps:

1. Create new [add-tutorial issue](https://github.com/fslaborg/fslaborg.github.io/issues/new/choose) by filling the issue template

2. In the `./src/content/tutorials_src` folder, create a new  `<YOUR_CONTENT>.fsx` file. Markdown articles will soon be supported as well.

3. Add the following frontmatter (starting on the very first line). Replace the `<>` placeholders with the actual correct information about your content:

    ```fsharp
    (***hide***)

    (*
    #frontmatter
    ---
    title: <YOUR TITLE HERE>
    category: <fsharp, datascience, or advanced>
    authors: <comma-separated list of authors>
    index: 0
    ---
    *)
    ```

4. Below the frontmatter, add the content of your article. If you are new to FSharp.Formatting, check the [docs there](http://fsprojects.github.io/FSharp.Formatting/) and also the documentation of the [fslab documentation template](https://fslab.org/docs-template/).

5. To get a preview of how your page will look like, in `./src` run the following command(s):

    ```shell
    dotnet tool restore
    dotnet fornax watch
    ```

    And navigate to the tutorials page on `http://localhost:8080`.

6. File a PR referencing the issue you created in step 1.

## Develop

### Prerequisites

- currently, .NET core 3.1.XXX is used, will be upgraded to .net5 when tools are ready
- you need to install [Sass(command line)](https://sass-lang.com/install) to compile the .scss styles to the actual stylesheet

To develop the project in watcher mode, go to `/src` and run:

- `dotnet tool restore`
- `dotnet fornax watch`

This will run a webserver that serves the compiled static page(s) on localhost:8080

### Technology used

- [Fornax](https://github.com/ionide/Fornax) a F# scriptable static webpage generator
- [FSharp.Formatting](https://github.com/fsprojects/FSharp.Formatting) for rendering of literate F# tutorials
- [Markdig](https://github.com/lunet-io/markdig), a markdown processor for .Net
- [Sass](https://sass-lang.com), a CSS extension language

gha_language: F#


text:
# The Ultimate Question

What do you get if you [multiply six by nine](http://en.wikipedia.org/wiki/Phrases_from_The_Hitchhiker%27s_Guide_to_the_Galaxy#Answer_to_the_Ultimate_Question_of_Life.2C_the_Universe.2C_and_Everything_.2842.29)?

### [Example](- "Google Calculator c:status=ExpectedToFail")
When I google [6 * 9](- "searchFor(#TEXT)") the answer should be [42](- "?=getCalculatorResult()").

_Hover and click on the red failure to see the screenshot._


text:
Work in progress

1. Start camera, CSI: `rosrun jetbot_ros jetbot_camera` or RealSense: `roslaunch realsense2_camera rs_camera.launch`

2. Calculate camera homography using the [estimator](https://github.com/alex-makarov/drive_ros_camera_homography):
 - Print the pattern
 - Place the robot in front of the pattern
 - Run the calibration: `roslaunch drive_ros_camera_homography homography_estimator.launch` and use dynamic_reconfigure to tune the parameters.
 - Frames for the pattern should be bigger than the pattern (didn't work for me otherwise).
 - Homography will be saved into the current folder, see example in the repo.

3. Use DCNN inference for [semantic segmentation](https://github.com/alex-makarov/ros-semantic-segmentation) to get the mask, like `rosrun semantic_segmentation segmentation_node __ns:=/jetbot_camera _topic_image:=camera`

4. TODO: Apply homography to the mask from segmentation and convert it into the local costmap


text:
# Tic-Tac-Toe

Coding assignment for Zendesk. A tic-tac-toe webapp made with React.js. Live demo available at https://bijan-massoumi.github.io/

### Installing

Run the app locally with the following sequence of commands: (If you don't have npm/ node, install them here: https://www.npmjs.com/get-npm)

```
git clone https://github.com/Bijan-Massoumi/ZenDesk-Homework.git
cd ZenDesk-Homework
npm install
npm start
```

### Features
    - The game enforces the conditions of X's win, O's win, as well as the draw condition.
    - The game allows for undo-ing one turn at a time. To do this, it stores all previous board states.
    - The board can be scaled up to a 5 x 5, 7 x 7, etc simply by editing the "size" member in the Game constructor.
    - The board can be reset at any time back to the original state.
    - There is updated info text to keep track of whose turn it is and who has won.

## Built With

* [React.js](https://reactjs.org/) - The web framework used
* [Foundation Grid](https://foundation.zurb.com/grid.html) - Css to simplify laying elements.
* [Font Awesome] (https://fontawesome.com/) - Where the refresh logo is from.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

repository: Bijan-Massoumi/ZenDesk-Homework

repo_name: Bijan-Massoumi/ZenDesk-Homework


text:
# JFFoundation

[![CI Status](https://img.shields.io/travis/jumpingfrog0/JFFoundation.svg?style=flat)](https://travis-ci.org/jumpingfrog0/JFFoundation)
[![Version](https://img.shields.io/cocoapods/v/JFFoundation.svg?style=flat&colorB=blue)](https://cocoapods.org/pods/JFFoundation)
[![License](https://img.shields.io/cocoapods/l/JFFoundation.svg?style=flat)](https://cocoapods.org/pods/JFFoundation)
[![Platform](https://img.shields.io/cocoapods/p/JFFoundation.svg?style=flat)](https://cocoapods.org/pods/JFFoundation)

Objective-C Foundation framework Category.

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

JFFoundation is available through [CocoaPods](https://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'JFFoundation', '~> 0.1.0'
```

## Author

jumpingfrog0<EMAIL_ADDRESS>
## License

JFFoundation is available under the MIT license. See the LICENSE file for more info.


text:
# spotfleet-admiral
SpotFleet Admiral

![89535d7f-48d2-4218-8ee4-3f0306dc3d7b](https://cloud.githubusercontent.com/assets/777823/18744748/87363288-80bf-11e6-9e48-0d43911fb266.jpg)

## Deploy

This library assumes your AWS credentials for Boto3 are already set up.

```
import admiral

specifications = {
	instance_types=['c3.large', 'c4.large'], // max 4
	subnets=['1-eeeeee'],
	user_data='your user data',
	iam_profile='arn:your-instance-profile',
	ami='ami-123123',
	security_groups='sg-123123',
	key_pair='key-name',
	ebs_optimized=False,
	block_devices=None, // you can pass an array of block devices
	placement=['us-east-1a', 'us-east-1b'], // not required if you are setting a subnet
	kernel=None, // pass a kernel ID
	monitoring=False, // enable instance monitoring
	network_interfaces=None, // pass an array of network interfaces
	ram=None, // pass a RamDiskId
	spot_price=None, // set a specific max for these instances (leave empty to use the SpotFleet max price)
	public_ip=True // associate a public IP for your instances
}

admiral.deploy(
	region='us-east-1', // spot region
	return_config=None, // return the config instead of trying to pass it on to AWS
	role='arn:this-spotfleet-role-is-required',
	strategy='diversified', // diversified || lowestPrice
	spot_price='2.000', // max price you ever want to pay for an instance
	specifications=specifications, // a separate object handled above
	capacity='2', // how many instances
	start_time=None, // when to bring up this spot fleet
	end_time=None // when to bring down this spot fleet
)
```

Review the tests for more implementation details.

repository: DeviaVir/spotfleet-admiral

repo_name: DeviaVir/spotfleet-admiral


text:
---
permalink: /docs/lifecycle/
title: Lifecycle
---

The lifecycle of EventSauce can be broken down into **3** steps:

1. [Interacting with the model](#interacting-with-the-model).
2. [Storing and dispatching raised events](#storing-and-dispatching-raised-events).
3. [Reacting to dispatched events](#reacting-to-dispatched-events).

## Interacting with the model

In order to interact with your model you'll need to
retrieve the `AggregateRoot` from the `AggregateRootRepository`.

### Retrieving the `AggregateRoot`

```php
$aggregateRoot = $repository->retrieve($aggregateRootId);
```

Retrieving an aggregate root fetches all the events that belong to
your aggregate root (related by aggregate root ID). You can reconstruct
an instance of your aggregate root by calling its `::reconstituteFromEvents`
method and passing the events to it.

The reconstitution process applies all the previously
recorded events on the instance. This brings our model to the current
state, ready for us to interact with it.

### Performing actions

Now that you've got the model, you can perform actions on it.
It is recommended to encapsulate this interaction in a **command
handler** or **service layer**.

```php
// Send a command to the aggregate root directly
$aggregateRoot->performAction($command);

// Or pass individual parameters
$aggregateRoot->performAnotherAction(
    $command->parameter(),
    $command->otherParameter()
);
```

In the aggregate you can now guard invariants and record events:

```php
// Inside our aggregate root class
public function performAction(SomeCommand $command)
{
    $this->guardBusinessRule($command);
    $this->recordThat(new SomeActionWasPerformed(
        $command->parameter(),
        $command->otherParameter()
    ));
}
```

Or if you used the parameterised approach:

```php
// Inside our aggregate root class
public function performAnotherAction(
    int $param1,
    string $param2
) {
    $this->guardBusinessRule($param1, $param2);
    $this->recordThat(new SomeActionWasPerformed(
        $param1,
        $param2
    ));
}
```

Whenever you record an event the `recordThat` ensures it's immediately
applied. This ensures the aggregate root is ready for the next interaction
without needing to re-retrieve it from the aggregate root repository.

```php
// Inside our aggregate root class
public function applySomeActionWasPerformed(SomeActionWasPerformed $event)
{
    // Use the data from the event to bring the current state up to date.
}
```

> It's important to note that applying events must **never** have side-effects.
> The only job of this function is to *use* the data from the event. Applying
> an event must not cause any exceptions.

## Storing and dispatching raised events

Once you're done interacting with the aggregate root you'll need to persist
the newly generated events.

```php
$repository->persist($aggregateRoot);
```

When you persist the events from an aggregate root the following things happen:

1. Events are pulled from the aggregate root.
2. The events are wrapped in `Message` objects.
3. The message objects are decorated (optional).
4. The messages are persisted in the `MessageRepository`.
5. The messages are dispatched by the `MessageDispatcher`.

## Reacting to dispatched events

Responding to messages is the final step of the event sourcing lifecycle.
The `MessageDispatcher` is responsible for passing `Message`s on to
`MessageConsumer`s.

Typical consumer types are:

* Projections: processes events to update "read models".
* Process Managers: listen to events and then perform actions.

```php
use EventSauce\EventSourcing\MessageConsumer;

class SomeConsumer implements MessageConsumer
{
    public function handle(Message $message)
    {
        $aggregateRootId = $message->aggregateRootId();
        $event = $message->event();
        $allHeaders = $message->headers();
        $requestId = $message->header('x-request-id');
    }
}
```

repository: EventSaucePHP/EventSauce

gha_language: PHP

repo_name: EventSaucePHP/EventSauce


text:
Manga Puppet

Sleek manga downloader & reader for Windows, MacOS, and Linux

## **Table of Contents**

[Download](#download)
[Screenshots](#screenshots)
[Why?](#why)
[Sources](#sources)
[Development](#development)
[Built With](#built-with)
[Contributing](#contributing)
[License](#license)

## **Download**

→ Coming soon

## **Screenshots**

![Manga view screenshot](screenshots/mangas.png)
![Chapters view screenshot](screenshots/chapters.png)
![Reader screenshot](screenshots/reader.png)

## **Why?**

Manga Puppet aims to be a sleek, accessible, and user-friendly manga downloading and reading option by providing a richer visual experience (cover images, manga information, etc.) as well as a cleaner and easier-to-navigate interface.

## **Sources**

As of now, only **MangaLife** has been implemented. More coming though!

## **Development**

Clone the repository

```bash
git clone https://github.com/lijandrew/manga-puppet.git
```

Navigate to the cloned directory

```bash
cd manga-puppet
```

Install dependencies

```bash
npm i
```

Start development app
_Note: live reload is only for the React frontend. Electron requires manual relaunching._

```bash
npm run dev
```

**_Temporary chromium fix: copy chromium installation folder from node_modules/puppeteer to ./chromium_**

## **Built With**

- [Electron](https://www.electronjs.org/)
- [React](https://reactjs.org/)
- [Puppeteer](https://github.com/puppeteer/puppeteer)
- [Axios](https://axios-http.com/)
- [JSDOM](https://github.com/jsdom/jsdom)
- [JSZip](https://stuk.github.io/jszip/)

## **Contributing**

PRs are appreciated!

## **License**

MIT

repository: lijandrew/manga-puppet

repo_name: lijandrew/manga-puppet


text:
# Forked from MontageJS Collections

This change log chronices the history of versions of the collections package
before it became a single repository with multiple projects.
Hereafter, individual packages are versioned and logged separately.

## v2.0.0 :warning: BACKWARD INCOMPATIBLE

-   Iterators have been reimplemented with an ES6 alike interface.
-   Change observers have been reimplemented with an FRB alike interface.
-   Removes support for `any` and `all`. Use `some(Boolean)` or
    `every(Boolean)`.

## v1.1.0

-   Adds an LfuSet, a set useful as a cache with a least-frequently-used
    eviction strategy.
-   Fixes array `set` and `swap` for indexes outside the bounds of the existing
    array, for both observed and unobserved arrays.

## v1.0.2

-   Refinements on `Object.equals` and `Object.compare`. These are not
    necessarily backward compatible, but should be a strict improvement:
-   `Object.compare` will now return +/- Infinity for inequal strings,
    rather than +/- 1 which imply that the distance between any two inequal
    strings is always 1. `Object.compare` for numbers is suitable for finding
    the magnitude of the difference as well as the direction.
-   `Object.compare` and `Object.equals` will now delegate to either non-null,
    non-undefined argument if the other argument is null or undefined.
    This allows objects to be constructed that will identify themselves
    as equivalent to null or undefined, for example `Any` types, useful for
    testing.
-   `Object.equals` will only compare object literals derrived directly from the
    `Object.prototype`. All other objects that do not implement `compare` are
    incomparable.
-   First attempt at fixing `set`, `swap`, and `splice`, later fixed in v1.0.3.
    `splice` must truncate the `start` index to the array length. `swap` and
    `set` should not.

## v1.0.1

-   Bug fix for filter on map-like collections.

## v1.0.0 :cake:

-   Adds a Deque type based on a circular buffer of exponential
    capacity.  (@petkaantonov)
-   Implements `peek`, `peekBack`, `poke`, and `pokeBack` on array
    shim for Deque “isomorphism”.
-   Fixes the cases where a change listener is added or removed during
    change dispatch. Neither listener will be informed until the next
    change. (@asolove)
-   The property change listener system has been altered such that
    once a thunk has been installed on an object, it will not be
    removed, in order to avoid churn. Once a property has been
    observed, it is likely to be observed again.
-   Fixes `Object.equals` for comparing NaN to itself, which should
    report `true` such that collections that use `Object.equals` to
    identify values are able to find `NaN`. Previously, `NaN` could
    get stuck in a collection permanently.
-   In abstract, Collections previously identified duck types by
    looking only at the prototype chain, ignoring owned properties.
    Thus, an object could distinguish a property name that was being
    used as a key of a record, from the same property name that was
    being used as a method name. To improve performance and to face
    the reality that oftentimes an owned property is in fact a method,
    Collections no longer observe this distinction. That is, if an
    object has a function by the appropriate name, either by ownership
    or inheritance, it will be recognized as a method of a duck type.
    This particularly affects `Object.equals`, which should be much
    faster now.
-   Fixes `Object.equals` such that property for property comparison
    between objects only happens if they both descend directly from
    `Object.prototype`. Previously, objects would be thus compared if
    they both descended from the same prototype.
-   Accommodate *very* large arrays with the `swap` shim. Previously,
    the size of an array swap was limited by the size of the
    JavaScript run-time stack. (@francoisfrisch)
-   Fixes `splice` on an array when given a negative start index.
    (@stuk)
-   Some methods accept an optional `equals` or `index` argument
    that may or may not be supported by certain collections, like
    `find` on a `SortedSet` versus a `List`. Collections that do not
    support this argument will now throw an error instead of silently
    ignoring the argument.
-   Fixes `Array#clone` cycle detection.

## v0.2.2

-   `one` now returns a consistent value between changes of a sorted
    set.
-   All collections can now be required using the MontageJS style, as
    well as the Node.js style. I reserve the right to withdraw support
    for the current MontageJS style if in a future,
    backward-incompatible release of Montage migrated to the Node.js
    style.

## v0.2.1

-   Identify Maps with `isMap` property instead of `keys`, as ES6
    proposes `keys`, `values`, and `entries` methods for arrays.

## v0.2.0

-   Fixes the enumerability of dispatchesRangeChanges and
    dispatchesMapChanges on observable arrays (and others,
    incidentally).
-   List and Set now dispatch valid range changes, at the penalty of
    making updates linear when they are made observable.
-   Adds `join` method to generic collections.
-   Fixes a bug in `Object.has(object, value)`, where it would not
    delegate polymorphically to `object.has(value)`
-   Fixes `Object.addEach(object, undefined)`, such that it tolerates
    the case without throwing an error, like `addEach` on other
    collections.
-   Fixes change dispatch on LruSet (Paul Koppen) such that a single
    change event gets dispatched for both augmentation and truncation.
-   Fixes change dispatch on Dict, such that the value gets sent on
    addition.

## v0.1.24

-   Factored out WeakMap into separately maintained package.

## v0.1.23

-   Introduces `entries` and deprecates `items` on all map collections.
-   Fixes Map clear change dispatch.

## v0.1.22

-   Fixes Set clear change dispatch.

## v0.1.21

-   Fixes a bug when the `plus` argument of swap is not an array.

## v0.1.20

-   Fixes generic map change dispatch on clear.
-   Adds map change dispatch to Dict.

## v0.1.18, v0.1.19

-   Require total order on SortedSet
-   Remove Node v0.6 from supported versions
-   Add Node v0.10 to supported versions
-   Fixes `hrtime` handling (Alexy Kupershtokh)

## v0.1.17

...

## v0.0.5

-   The `observable-array` and `observable-object` modules have been
    moved to the Functional Reactive Bindings (`frb`) package as `array`
    and `object`.
-   `List`, `Set`, and `SortedSet` now support content change
    notifications compatibly with `frb`.
-   The `observable` module provides generics methods for observables.
    New collections need only call the appropriate dispatch functions if
    `isObservable` is true.

repository: kriskowal/collections

repo_name: kriskowal/collections


text:
## pronounce

### description
pronounce word in command line.

### usage
```bash
$ pronounce hello world
```

### install
```bash
$ npm i -g pronounce
```
have fun!

### If you want another name instead of `pronounce` you can manual install:
- `git clone git@github.com:iwestlin/pronounce.git` && `cd pronounce`
- edit `package.json`:
```
  "bin": {
    "whatever-cmd-you-like": "./bin/pronounce"
  }
```
- run `npm link` to add `whatever-cmd-you-like` to PATH

### license
MIT

repository: iwestlin/pronounce

repo_name: iwestlin/pronounce


text:
---
excerpt: Meet Injection Helper, a small utility for making InjectionForXcode
  more friendly to use. Get rid of superfluous messages and a flood of XCode
  windows opened any time you patch/revert your project.
modified: 2014-11-07T00:00:00.000Z
layout: post
title: InjectionForXcode meets command line
date: 2014-11-06T23:00:00.000Z
image: /images/bright_team-compressor.jpg
author: michal
tags:
  - ios
  - appcode
  - xcode
  - injectionforxcode
  - gem
hidden: false
comments: true
published: true
language: en
---
I find [InjectionForXcode](http://injectionforxcode.com/) to be an indispensable tool in my daily iOS development. It works brilliantly but generates a lot of noise that I just couldn’t cope with.

I use AppCode. Whenever I execute `Run -> Patch Project For Injection` there’s a flood of messages telling me about changes in each individual `prefix.pch` file. There’s one prefix file for each CocoaPod in the project so you can imagine the pain of having to press “OK” button in a dozen of alert messages. Additionally after each file has been modified Xcode opens and shows the updated code. Yuck. You can live with this if you patch project for injection once and then keep patched project in your repository. The thing is that I don’t want to keep patched project in the repository. I don’t want to force InjectionForXcode onto other people working on the code. I want to quickly patch the project, do what I need to do and then revert the project to its previous state.

There’s also one other problem. I really hate the alert message that appears in the running app every time some code has been injected. I know that injection takes place because I initiate it. I immediately see the change in the app, I don’t need another alert message confirming it. After all I can always use [Blinker](https://github.com/bright/blinker) to indicate a change.

So many issues with such a great tool.  It’s called [Injection Helper](https://github.com/bright/injection-helper) and you can install it by executing:

```Bash
gem install injection-helper
```

Here’s what you can do with it.

## Turn on mute mode for InjectionForXcode

Just execute `injection mute` from your project directory and you won’t see any more of those pesky messages.  There will also be no Xcode windows opened when you patch project for injection (or revert injection code) next time.

You can always unmute it by executing `injection unmute`.

## Patch project for injection from command line

It’s easier and feels better to patch project for injection straight from your command line.
Just go to your project directory and execute: `injection patch` to patch project or `injection revert` to remove all the boilerplate code.

There’s also `injection refresh` command that reverts injection changes and then patches the project again. It’s great if you run your app on a real device and don’t want to change your ip address in `main.m` every time you switch your wifi.

repository: bright/new-www

branch_name: refs/heads/gatsby

repo_name: bright/new-www


text:
# Spaziergang Creator [![Build Status](https://travis-ci.org/Datenschule/spaziergang-creator.svg?branch=master)](https://travis-ci.org/Datenschule/spaziergang-creator) [![Coverage Status](https://coveralls.io/repos/github/Datenschule/spaziergang-creator/badge.svg)](https://coveralls.io/github/Datenschule/spaziergang-creator)

## What is this?

Spaziergang Creator a web-based tool to create your own [Datenspaziergang](https://github.com/Datenschule/datenspaziergang-app).

It also serves as an API server for the mentioned frontend app.

## Development setup

> Ruby 2.5.1
> A recent version of node

Clone the repo and run `$ bundle` (install bundler via `gem install bundler` if you haven't yet).

Copy and adjust the database config `$ cp config/database.yml.example config/database.yml`.

Setup database and run migrations `$ rails db:create db:migrate`.

Install JavaScript dependencies via npm/yarn `$ npm install` or `$ yarn install`.

Start the dev server `$ rails s`.

## Tests

Run tests locally via `$ rspec`.

## Deployment/ Production

I use docker/ docker-compose to build and serve the production app.

The `docker-compose.yml` defines three services in a network:

- postgres, called `db`
- the Spaziergang Creator app, called `web`
- nginx to serve and cache static assets, called `nginx`

**Please adjust the variables in the docker-compose.yml before deployment!**

Give the database a proper name, user and password (db and web have to match) and change the `secret_key_base` in the web service. Adjust the port in nginx to whatever port you want to expose.

After that you can `$ docker-compose build` to build the images and `$ docker-compose up -d` to start the whole thing.

When you set this up for the **first time** don't forget run the database migrations with `$ docker exec spaziergang-creator_web_1 rails db:migrate`. Pid instead of container name also works.

Yay!

## API docs

There are two API endpoints, `/api/v1/walks` and `/api/v1/walks/:id` serving a list of public walks and details of one walk respectively.

The payloads are designed to match [the original payload of the prototype](https://github.com/Datenschule/datenspaziergang-app/wiki).

repository: schoolofdata-ch/spaziergang-creator

repo_name: schoolofdata-ch/spaziergang-creator