Jekyll2023-02-07T02:04:01+00:00https://kevkeyingli.github.io/feed.xmlWeb Developer, Data Visualization, Machine Learning, Music Lover...2020-08-01T00:00:00+00:002020-08-01T00:00:00+00:00https://kevkeyingli.github.io/Next-Technology-Revolution<h1 id="next-technology-revolution">Next Technology Revolution</h1> <p>Science and Technology is the driving force of all human world advancements. From steam engine to electricity, information technologies to artificial intelligence. Here are some of the up and coming technological trend that will change the world.</p> <h2 id="genetic-engineering-to-change-humans-relationship-with-its-own-physiology">Genetic Engineering to change human’s relationship with its own physiology.</h2> <p>Gene editing, Gene therapy, potentially genetic enhancements(with radical ideological revolution and emancipation)</p> <h2 id="brain-computer-interface-to-change-human-computer-interaction">Brain Computer Interface to change human computer interaction</h2> <p>Revolutionize human computer interaction from physically typing, clicking, tabbing, seeing, hearing, reading to mentally two way signaling.</p> <p>A whole other level from the VR/AR/MR we dream of today.</p> <p>Interpersonal interaction will advance from phone call, text message, video chat to a whole new level of mind sharing.</p> <p>Human will need to find ways and learn to share what they want, and protect what they don’t want to share. (Like in Inception)</p> <p>Protecting privacy, peace of mind will be extremely challenging.</p>

Next Technology Revolution Science and Technology is the driving force of all human world advancements. From steam engine to electricity, information technologies to artificial intelligence. Here are some of the up and coming technological trend that will change the world.

2018-09-22T00:00:00+00:002018-09-22T00:00:00+00:00https://kevkeyingli.github.io/Effective-Java-Ch1<p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #322-325的标注</td> <td>添加于 2018年9月19日星期三 下午9:26:34</td> </tr> </tbody> </table> </li> </ul> <h1 id="clarity-and-simplicity-are-of-paramount-importance-the-user-of-a-component-should-never-be-surprised-by-its-behavior-components-should-be-as-small-as-possible-but-no-smaller-as-used-in-this-book-the-term-component-refers-to-any-reusable-software-element-from-an-individual-method-to-a-complex-framework-consisting-of-multiple-packages-code-should-be-reused-rather-than-copied-the-dependencies-between-components-should-be-kept-to-a-minimum-errors-should-be-detected-as-soon-as-possible-after-they-are-made-ideally-at-compile-time">Clarity and simplicity are of paramount importance. The user of a component should never be surprised by its behavior. Components should be as small as possible but no smaller. (As used in this book, the term component refers to any reusable software element, from an individual method to a complex framework consisting of multiple packages.) Code should be reused rather than copied. The dependencies between components should be kept to a minimum. Errors should be detected as soon as possible after they are made, ideally at compile time.</h1> <p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #327-328的标注</td> <td>添加于 2018年9月19日星期三 下午9:27:06</td> </tr> </tbody> </table> </li> </ul> <h1 id="learning-the-art-of-programming-like-most-other-disciplines-consists-of-first-learning-the-rules-and-then-learning-when-to-break-them">Learning the art of programming, like most other disciplines, consists of first learning the rules and then learning when to break them.</h1> <p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #362-366的标注</td> <td>添加于 2018年9月19日星期三 下午9:29:31</td> </tr> </tbody> </table> </li> </ul> <h1 id="the-language-supports-four-kinds-of-types-interfaces-including-annotations-classes-including-enums-arrays-and-primitives-the-first-three-are-known-as-reference-types-class-instances-and-arrays-are-objects-primitive-values-are-not-a-classs-members-consist-of-its-fields-methods-member-classes-and-member-interfaces-a-methods-signature-consists-of-its-name-and-the-types-of-its-formal-parameters-the-signature-does-not-include-the-methods-return-type">The language supports four kinds of types: interfaces (including annotations), classes (including enums), arrays, and primitives. The first three are known as reference types. Class instances and arrays are objects; primitive values are not. A class’s members consist of its fields, methods, member classes, and member interfaces. A method’s signature consists of its name and the types of its formal parameters; the signature does not include the method’s return type.</h1> <p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #367-370的标注</td> <td>添加于 2018年9月19日星期三 下午9:30:16</td> </tr> </tbody> </table> </li> </ul> <h1 id="unlike-the-java-language-specification-this-book-uses-inheritance-as-a-synonym-for-subclassing-instead-of-using-the-term-inheritance-for-interfaces-this-book-simply-states-that-a-class-implements-an-interface-or-that-one-interface-extends-another-to-describe-the-access-level-that-applies-when-none-is-specified-this-book-uses-the-traditional-package-private-instead-of-the-technically-correct-package-access">Unlike The Java Language Specification, this book uses inheritance as a synonym for subclassing. Instead of using the term inheritance for interfaces, this book simply states that a class implements an interface or that one interface extends another. To describe the access level that applies when none is specified, this book uses the traditional package-private instead of the technically correct package access</h1> <p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #371-375的标注</td> <td>添加于 2018年9月19日星期三 下午9:31:01</td> </tr> </tbody> </table> </li> </ul> <h1 id="the-term-exported-api-or-simply-api-refers-to-the-classes-interfaces-constructors-members-and-serialized-forms-by-which-a-programmer-accesses-a-class-interface-or-package-the-term-api-which-is-short-for-application-programming-interface-is-used-in-preference-to-the-otherwise-preferable-term-interface-to-avoid-confusion-with-the-language-construct-of-that-name-a-programmer-who-writes-a-program-that-uses-an-api-is-referred-to-as-a-user-of-the-api-a-class-whose-implementation">The term exported API, or simply API, refers to the classes, interfaces, constructors, members, and serialized forms by which a programmer accesses a class, interface, or package. (The term API, which is short for application programming interface, is used in preference to the otherwise preferable term interface to avoid confusion with the language construct of that name.) A programmer who writes a program that uses an API is referred to as a user of the API. A class whose implementation</h1> <p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #371-375的标注</td> <td>添加于 2018年9月19日星期三 下午9:31:06</td> </tr> </tbody> </table> </li> </ul> <h1 id="the-term-exported-api-or-simply-api-refers-to-the-classes-interfaces-constructors-members-and-serialized-forms-by-which-a-programmer-accesses-a-class-interface-or-package-the-term-api-which-is-short-for-application-programming-interface-is-used-in-preference-to-the-otherwise-preferable-term-interface-to-avoid-confusion-with-the-language-construct-of-that-name-a-programmer-who-writes-a-program-that-uses-an-api-is-referred-to-as-a-user-of-the-api-a-class-whose-implementation-1">The term exported API, or simply API, refers to the classes, interfaces, constructors, members, and serialized forms by which a programmer accesses a class, interface, or package. (The term API, which is short for application programming interface, is used in preference to the otherwise preferable term interface to avoid confusion with the language construct of that name.) A programmer who writes a program that uses an API is referred to as a user of the API. A class whose implementation</h1> <p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #371-375的标注</td> <td>添加于 2018年9月19日星期三 下午9:31:16</td> </tr> </tbody> </table> </li> </ul> <h1 id="the-term-exported-api-or-simply-api-refers-to-the-classes-interfaces-constructors-members-and-serialized-forms-by-which-a-programmer-accesses-a-class-interface-or-package-the-term-api-which-is-short-for-application-programming-interface-is-used-in-preference-to-the-otherwise-preferable-term-interface-to-avoid-confusion-with-the-language-construct-of-that-name-a-programmer-who-writes-a-program-that-uses-an-api-is-referred-to-as-a-user-of-the-api-a-class-whose-implementation-uses-an-api-is-a-client-of-the-api">The term exported API, or simply API, refers to the classes, interfaces, constructors, members, and serialized forms by which a programmer accesses a class, interface, or package. (The term API, which is short for application programming interface, is used in preference to the otherwise preferable term interface to avoid confusion with the language construct of that name.) A programmer who writes a program that uses an API is referred to as a user of the API. A class whose implementation uses an API is a client of the API.</h1> <p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #371-375的标注</td> <td>添加于 2018年9月19日星期三 下午9:31:22</td> </tr> </tbody> </table> </li> </ul> <h1 id="the-term-exported-api-or-simply-api-refers-to-the-classes-interfaces-constructors-members-and-serialized-forms-by-which-a-programmer-accesses-a-class-interface-or-package-the-term-api-which-is-short-for-application-programming-interface-is-used-in-preference-to-the-otherwise-preferable-term-interface-to-avoid-confusion-with-the-language-construct-of-that-name-a-programmer-who-writes-a-program-that-uses-an-api-is-referred-to-as-a-user-of-the-api-a-class-whose-implementation-uses-an-api-is-a-client-of-the-api-1">The term exported API, or simply API, refers to the classes, interfaces, constructors, members, and serialized forms by which a programmer accesses a class, interface, or package. (The term API, which is short for application programming interface, is used in preference to the otherwise preferable term interface to avoid confusion with the language construct of that name.) A programmer who writes a program that uses an API is referred to as a user of the API. A class whose implementation uses an API is a client of the API.</h1> <p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #375-380的标注</td> <td>添加于 2018年9月19日星期三 下午9:31:58</td> </tr> </tbody> </table> </li> </ul> <h1 id="classes-interfaces-constructors-members-and-serialized-forms-are-collectively-known-as-api-elements-an-exported-api-consists-of-the-api-elements-that-are-accessible-outside-of-the-package-that-defines-the-api-these-are-the-api-elements-that-any-client-can-use-and-the-author-of-the-api-commits-to-support-not-coincidentally-they-are-also-the-elements-for-which-the-javadoc-utility-generates-documentation-in-its-default-mode-of-operation-loosely-speaking-the-exported-api-of-a-package-consists-of-the-public-and-protected-members-and-constructors-of-every-public-class-or-interface-in-the-package">Classes, interfaces, constructors, members, and serialized forms are collectively known as API elements. An exported API consists of the API elements that are accessible outside of the package that defines the API. These are the API elements that any client can use and the author of the API commits to support. Not coincidentally, they are also the elements for which the Javadoc utility generates documentation in its default mode of operation. Loosely speaking, the exported API of a package consists of the public and protected members and constructors of every public class or interface in the package.</h1> <p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #375-380的标注</td> <td>添加于 2018年9月19日星期三 下午9:32:18</td> </tr> </tbody> </table> </li> </ul> <h1 id="classes-interfaces-constructors-members-and-serialized-forms-are-collectively-known-as-api-elements-an-exported-api-consists-of-the-api-elements-that-are-accessible-outside-of-the-package-that-defines-the-api-these-are-the-api-elements-that-any-client-can-use-and-the-author-of-the-api-commits-to-support-not-coincidentally-they-are-also-the-elements-for-which-the-javadoc-utility-generates-documentation-in-its-default-mode-of-operation-loosely-speaking-the-exported-api-of-a-package-consists-of-the-public-and-protected-members-and-constructors-of-every-public-class-or-interface-in-the-package-1">Classes, interfaces, constructors, members, and serialized forms are collectively known as API elements. An exported API consists of the API elements that are accessible outside of the package that defines the API. These are the API elements that any client can use and the author of the API commits to support. Not coincidentally, they are also the elements for which the Javadoc utility generates documentation in its default mode of operation. Loosely speaking, the exported API of a package consists of the public and protected members and constructors of every public class or interface in the package.</h1> <p>Effective Java, Third Edition (Joshua Bloch)</p> <ul> <li> <table> <tbody> <tr> <td>您在位置 #380-381的标注</td> <td>添加于 2018年9月19日星期三 下午9:32:38</td> </tr> </tbody> </table> </li> </ul> <h1 id="module-system-was-added-to-the-platform-if-a-library-makes-use-of-the-module-system-its-exported-api-is-the-union-of-the-exported-apis-of-all-the-packages-exported-by-the-librarys-module-declaration">module system was added to the platform. If a library makes use of the module system, its exported API is the union of the exported APIs of all the packages exported by the library’s module declaration.</h1> <h1 id="note-template">Note template</h1> <h2 id="what-the-problem-to-solve">What? The problem to solve</h2> <h2 id="how-the-pattern">How? The pattern</h2> <h2 id="compare-other-solutions-and-patterns">Compare? Other solutions and patterns,</h2> <h2 id="benefits">Benefits</h2> <h2 id="shortcomings">Shortcomings</h2> <h2 id="where-to-use-and-where-not-examples">Where to use and where not, examples</h2> <h2 id="related-java-knowledge">Related Java Knowledge</h2> <h2 id="terminologies">Terminologies</h2> <h2 id="related-patterns--references">Related patterns &amp; references</h2>

Effective Java, Third Edition (Joshua Bloch) 您在位置 #322-325的标注 添加于 2018年9月19日星期三 下午9:26:34

2018-09-22T00:00:00+00:002018-09-22T00:00:00+00:00https://kevkeyingli.github.io/Effective-Java-Item-1<h1 id="chapter-2-creating-and-destroying-objects">Chapter 2 Creating and Destroying Objects</h1> <h2 id="item-1-consider-static-factory-methods-instead-of-constructors">Item 1 Consider static factory methods instead of constructors:</h2> <p>A class can provide its clients with static factory methods instead of, or in addition to, public constructors. Providing a static factory method instead of a public constructor has both advantages and disadvantages.</p> <p>Example:</p> <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code> public static Boolean valueOf(boolean b) { return b ? Boolean.TRUE : Boolean.FALSE; } </code></pre></div></div> <h2 id="terminologies">Terminologies</h2> <p><strong>instance controlled</strong> The ability of static factory methods to return the same object from repeated invocations allows classes to maintain strict control over what instances exist at any time. Classes that do this are said to be instance-controlled.</p> <p><strong>service provider frameworks</strong> e.g. JDBC A service provider frameworks is a system in which providers implement a service, and the system makes the implementations available to clients, decoupling the clients from the implementation</p> <p>There are three essential components in a <strong>service provider framework</strong>:</p> <ul> <li>a <em>service interface</em>, which represents an implementation;</li> <li>a <em>provider registration API</em>, which providers use to register implementations; and</li> <li>a <em>service access API</em>, which clients use to obtain instances of the service. The service access API may allow clients to specify criteria for choosing an implementation, return a default implementation, or let client cycle through all available implementations. This is the flexible static factory that forms the basis of the service provider framework.</li> <li>An optional fourth component of a service provider framework is <em>a service provider interface</em>, which describes a factory object that produce instances of the service interface.</li> </ul> <p>There are many variants of the service provider framework pattern:</p> <ul> <li>the service access api can return a richer service interface to client than the one furnished by providers. <em>Birdge pattern [Gamma 95]</em></li> <li><em>Dependency injection framworks (Item 5)</em> can be viewed as powerful service providers.</li> <li>Since Java 6, the platform includes a general-purpose service provider framework, <em>java.util.ServiceLoader (Item 59)</em>, which you should generally use</li> <li>JDBC doesn’t use ServiceLoader, since it’s earlier.</li> </ul> <h2 id="benefitsreasons">Benefits/reasons:</h2> <ol> <li>Unlike constructors, <strong>static factory methods have names</strong> <ul> <li>a well-chosen name results in client code easier to read.</li> <li>Creating multiple constructors with different param types is bad. replacing multiple constructors with same signature with static factory methods with carefully chosen names highlights their differences.</li> </ul> </li> <li>Unlike constructores, <strong>static factory methods are not required to create new object each time they’re called.</strong> <ul> <li>This allows <em>immutable classes[Item 17]</em> to use preconstructed instances or cache and reuse constructed instances. e.g. Boolean never creates an object.</li> <li>This is similar technique to <em>Flyweight pattern</em></li> <li>improves performance, if equivalent object is requested often and expensive to create.</li> <li>This ability makes the classes <strong>instance controlled</strong>. There are several reasons to write instance-controlled classes. <ul> <li>Instance control allows a class to guarantee that it is a <em>singleton (Item 3)</em> or <em>noninstantiable (Item 4)</em>.</li> <li>Also, it allows an <em>immutable value class (Item 17)</em> to make the guarantee that no two equal instances exist: a.equals(b) if and only if a == b. This is the basis of the <em>Flyweight pattern [Gamma95]</em>. <em>Enum types(item 34)</em> provide this guarantee.</li> </ul> </li> </ul> </li> <li>A third advantage of static factory methods is that, unlike constructors, <strong>they can return an object of any subtype of their return type</strong> -&gt; great flexibility in choosing the class of the returned object. <ul> <li>One application of this flexibility is that an API can return objects without making their classes public. Hiding implementation classes in this fashion leads to a very compact API. This technique lends itself to <em>interface-based frameworks (Item 20)</em>, where interfaces provide natural return types for static factory methods. <blockquote> <p>Prior to Java 8, interfaces couldn’t have static methods. By convention, static factory methods for an interface named Type were put in a <em>noninstantiable companion class (Item 4)</em> named Types.” java.util.collections has 45 convenience implementations of its collection interface, nearly all of these implementations are exported via static factory methods in one non-instantiable class java.util.Collections, the classes of the returned objects are all non-public. examples: java.util.Collections and java.util.EnumSet(Item 36). The Collections Framework API is much smaller than it would have been had it exported forty-five separate public classes, one for each convenience implementation. It is not just the bulk of the API that is reduced but the conceptual weight: the number and difficulty of the concepts that programmers must master in order to use the API. Java 8 requires all static members of an interface to be public. Java 9 allows private static methods, but static fields and static member classes are still required to be public.</p> </blockquote> </li> </ul> </li> <li>A fourth advantage of static factories is that the class of the returned object can vary from call to call as a function of the input parameters. Any subtype of the declared return type is permissible.</li> <li>A fifth advantage of static factories is that the class of the returned object need not exist when the class containing the method is written.</li> </ol> <p>##Limitation/Shortcoming</p> <ul> <li>The main limitation of providing only static factory methods is that classes without public or protected constructors cannot be subclassed. <ul> <li>Arguably this can be a blessing in disguise because it encourages programmers to <em>use composition instead of inheritance (Item 18)</em>, and is required for <em>immutable types (Item 17)</em></li> </ul> </li> <li>A second shortcoming of static factory methods is that they are hard for programmers to find. They don’t stand out in API docs as constructors. In the meantime, you can reduce this problem by drawing attention to static factories in class or interface documentation and by adhering to <strong>common naming conventions</strong>. Here are some common names for static factory methods. <ul> <li><code class="language-plaintext highlighter-rouge">from</code> – A type-conversion method</li> <li><code class="language-plaintext highlighter-rouge">of</code> – An aggregation method</li> <li><code class="language-plaintext highlighter-rouge">valueOf</code> – A more verbose alternative to <code class="language-plaintext highlighter-rouge">from</code> and <code class="language-plaintext highlighter-rouge">of</code></li> <li><code class="language-plaintext highlighter-rouge">instance</code> or <code class="language-plaintext highlighter-rouge">getInstance</code> reutnrs an instance that is described by its parameters</li> <li><code class="language-plaintext highlighter-rouge">create</code> or <code class="language-plaintext highlighter-rouge">newInstance</code> each call should guarantee to return a <strong>new</strong> instance.</li> <li><code class="language-plaintext highlighter-rouge">get[Type]</code> like <code class="language-plaintext highlighter-rouge">getInstance</code>, but returns instance of a different class indicated by <code class="language-plaintext highlighter-rouge">Type</code> in the name. e.g. <code class="language-plaintext highlighter-rouge">getFileStore</code>.</li> <li><code class="language-plaintext highlighter-rouge">new[Type]</code> like <code class="language-plaintext highlighter-rouge">newInstance</code>, but returns a new instance of a different class. e.g. <code class="language-plaintext highlighter-rouge">newBufferedReader()</code></li> <li><code class="language-plaintext highlighter-rouge">[type]</code>: a concise alternative to <code class="language-plaintext highlighter-rouge">get[Type]</code> and <code class="language-plaintext highlighter-rouge">new[Type]</code> e.g. <code class="language-plaintext highlighter-rouge">Collections.list()</code></li> </ul> </li> </ul> <h2 id="summary">Summary</h2> <p>Static factory and constructors both have their uses, and it pays to understand their relative merits. <strong>Often static factories are preferable, so avoid the reflex to provide public constructors without first considering static factories.</strong></p> <h2 id="related-java-knowledge">Related Java Knowledge</h2> <p>Java 8 requires all static members of an interface to be public. Java 9 allows private static methods, but static fields and static member classes are still required to be public.</p> <h2 id="related-patterns--references">Related patterns &amp; references</h2> <ul> <li>Flyweight pattern</li> <li><em>immutable classes[Item 17]</em></li> <li><em>singleton (Item 3)</em></li> <li><em>noninstantiable (Item 4)</em></li> <li><em>Enum types(item 34)</em></li> <li><em>noninstantiable companion class (Item 4)</em></li> <li><em>refering to returned object by interface rather than implementation class is good practice(Item 64)</em></li> <li>The enumSet class (Item 36 )</li> <li><em>use composition instead of inheritance (Item 18)</em></li> <li><em>immutable types (Item 17)</em></li> </ul>

Chapter 2 Creating and Destroying Objects

2018-09-22T00:00:00+00:002018-09-22T00:00:00+00:00https://kevkeyingli.github.io/Effective-Java-Item-2

2017-09-10T00:00:00+00:002017-09-10T00:00:00+00:00https://kevkeyingli.github.io/...-in-JS<p>“…” is an important new feature in ES6, that brings simplicity and elegance to JS.</p> <p>Briefly the … three dots actually have two different identities in different scenarios. <strong>Spread Syntax(Operators)</strong> and <strong>Rest Syntax(Parameters)</strong>.</p> <p>As MDN described it:</p> <p><strong>Spread syntax</strong></p> <ul> <li>allows an iterable such as an array expression to be <strong>expanded</strong> in places where zero or more arguments (for function calls) or elements (for array literals) are expected,</li> <li>or an object expression to be <strong>expanded</strong> in places where zero or more key-value pairs (for object literals) are expected.</li> </ul> <p><strong>Rest Parameters</strong></p> <ul> <li>The rest parameter syntax allows us to represent an <strong>indefinite number of arguments as an array</strong>.</li> </ul> <p>The names are self-explanatory. **Spread operator operates on, and expands array or object. while rest parameters represent the rest parameters in a function definition. **</p> <p>For examples of these two use cases, go to the MDN site which includes a good number of different ways of using …:</p> <ul> <li>https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator</li> <li>https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters</li> </ul> <p>For a little history of how … changed javascript and life of millions of developers, here is a good article:</p> <ul> <li>https://dmitripavlutin.com/how-three-dots-changed-javascript/</li> </ul>

“…” is an important new feature in ES6, that brings simplicity and elegance to JS.

2017-05-24T00:00:00+00:002017-05-24T00:00:00+00:00https://kevkeyingli.github.io/Useful-Technical-Resources<p>Free books from oreilly http://www.oreilly.com/programming/free/</p> <h2 id="javascript">Javascript</h2> <ul> <li>Best Javascript doc site: MDN</li> <li>A re-introduction to JavaScript (JS tutorial by MDN) https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript</li> </ul>

Free books from oreilly http://www.oreilly.com/programming/free/

2016-10-28T00:00:00+00:002016-10-28T00:00:00+00:00https://kevkeyingli.github.io/MongoDB<p>This learning note follows the tutorial <a href="https://www.youtube.com/watch?v=pWbMrx5rVBE">MongoDB In 30 Minutes</a> on Youtube.</p> <h2 id="set-up">Set up</h2> <ul> <li>Download and install</li> <li>make a few folders where you want to store your database</li> <li>and set the path to be used by mongodb: <ul> <li><code class="language-plaintext highlighter-rouge">mongod --directoryperdb --path 'directory' --logpath 'logpath/mongo.log' --logappend --rest --install</code> installs the mongodb as a rest service</li> </ul> </li> <li>Now we can run the service: <code class="language-plaintext highlighter-rouge">net start MongoDB</code>(This is for windows only). the MongoDB now can run on the background as a service.</li> <li>type in <code class="language-plaintext highlighter-rouge">mongo</code> and you are in the mongoDB shell.</li> </ul> <h2 id="usual-commands">Usual commands</h2> <ul> <li><code class="language-plaintext highlighter-rouge">show dbs</code>: shows all the databases, don;t touch the default database <code class="language-plaintext highlighter-rouge">local</code></li> <li><code class="language-plaintext highlighter-rouge">use databasename</code>: creates a new database</li> <li><code class="language-plaintext highlighter-rouge">db</code> shows you the current database you are in.</li> <li>MongoDB use JSON format to interact with data. Can contain: string, number, array, objects, basically any normal data structure.</li> <li> <p>to create a user:</p> <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code> db.createUser({ user:"username", pwd:"password", roles:["roles of the user"] }); </code></pre></div> </div> </li> <li><code class="language-plaintext highlighter-rouge">db.createCollection('customers')</code> create a collection(table)</li> <li><code class="language-plaintext highlighter-rouge">show collections</code> will show all the collections</li> <li><code class="language-plaintext highlighter-rouge">db.customers.insert({one json like entry})</code>, note that ‘customer’</li> </ul> <p>Everytime a new entry is inserted, an id is assigned.</p> <ul> <li><code class="language-plaintext highlighter-rouge">db.customers.find()</code></li> <li><code class="language-plaintext highlighter-rouge">db.customers.find().pretty()</code></li> <li><code class="language-plaintext highlighter-rouge">db.customers.update({first_name:"John"},{first_name:"John", last_name:"...", })</code>: replace an entry with a new entry, The ID does not change. The first parameter is used as a condition like <code class="language-plaintext highlighter-rouge">WHERE</code>.</li> <li> <p>How to update only one field(change/add/delete): Use operators : <code class="language-plaintext highlighter-rouge">$set</code>, <code class="language-plaintext highlighter-rouge">$inc</code>, <code class="language-plaintext highlighter-rouge">$unset</code></p> <p>db.customers.update({condition},{$$$set:{gender:”male”}}) db.customers.update({condition},{$$$inc:{age:5}}) db.customers.update({first_name:”Steve”},{$$$unset:{age}})</p> </li> <li><code class="language-plaintext highlighter-rouge">db.customers.update({first_name:"NoExistName"},{first_name:"NoExistName", last_name:"K",},{upsert:true}); </code> we can add a new entry if it is not find.</li> <li><code class="language-plaintext highlighter-rouge">db.customers.update({condition},{$rename:{"gender":"sex"});</code>: change attribute name</li> <li><code class="language-plaintext highlighter-rouge">db.customer.remove({conditions},{justOne:true})</code>remove the matching entries, if <code class="language-plaintext highlighter-rouge">justOne</code> is not specified, all matches will be deleted.</li> <li><code class="language-plaintext highlighter-rouge">db.customers.find($or:[{condition one},{condition two}])</code> using logic operator.</li> <li><code class="language-plaintext highlighter-rouge">$lt</code>,<code class="language-plaintext highlighter-rouge">$gt</code>,<code class="language-plaintext highlighter-rouge">$lte</code>,<code class="language-plaintext highlighter-rouge">$gte</code>: <code class="language-plaintext highlighter-rouge">db.customers.find({age:{$lt:40}}).pretty();</code></li> <li><code class="language-plaintext highlighter-rouge">db.customers.find({"address.city":"Boston"});</code> : using attribute of attribute(member of dictionary, which is also a member of a dictionary). <strong>Note</strong>: dontforget the quots in <code class="language-plaintext highlighter-rouge">"address.city"</code>.</li> <li>Last one queried a <strong>Dictionary</strong>, we can also query an <strong>Array</strong>. For example, every/some entries have attribute <code class="language-plaintext highlighter-rouge">membership=['mem1','mem2']</code> which is an array containing different kinds of memberships. we can do: <code class="language-plaintext highlighter-rouge">db.customers.find({membership:"mem1"});</code></li> <li>Sorting by some attribute: <code class="language-plaintext highlighter-rouge">db.customer.find().sort({last_name:1}).pretty()</code>. <code class="language-plaintext highlighter-rouge">1</code> for ascending, <code class="language-plaintext highlighter-rouge">-1</code> for descending.</li> <li>Count documents: <code class="language-plaintext highlighter-rouge">db.customers.find({conditions}).count();</code></li> <li>Set limit: <code class="language-plaintext highlighter-rouge">db.customers.find({conditions}).limit(4).sort({last_name:1});</code></li> <li>Iterate using <code class="language-plaintext highlighter-rouge">forEach</code>: <code class="language-plaintext highlighter-rouge">db.customers.find().forEach(function(doc){print(doc.first_name)});</code> this could call javascript function.</li> </ul>Kevin

This learning note follows the tutorial MongoDB In 30 Minutes on Youtube.

2016-08-15T00:00:00+00:002016-08-15T00:00:00+00:00https://kevkeyingli.github.io/Reading%20note%20for%20Introduction%20to%20Algorithms<h1 id="reading-note-for-introduction-to-algorithms">Reading note for Introduction to Algorithms</h1> <h2 id="foundations">Foundations</h2> <h2 id="and-order-statistics">and Order Statistics</h2> <h2 id="data-structures">Data Structures</h2> <h2 id="advanced-design-and-analysis-techniques">Advanced Design and Analysis Techniques</h2> <h3 id="dynamic-programming">Dynamic Programming</h3> <p>DP is typically used for solving optimization problems, there are basically four steps:</p> <ul> <li>Characterize the structure of an optimal solution</li> <li>Recursively define the value of an optimal solution</li> <li>compute the value of an optimal solution, typically in a bottom-up fashion(top-down memoization is also usable some times)</li> <li>Construct an optimal solution from the computed information(Interview questions might not need this) <h2 id="151-rod-cutting-problem">15.1 Rod cutting problem</h2> <p>Rod cutting problem exhibits <strong>optimal substructure</strong>: optimal solution to a problem incorpporate optimal solution to related <strong>subproblems</strong>, which we may solve <strong>independently</strong>.</p> </li> </ul> <p>The biggest benefit of DP is to reduce the overlapping/wasted computations. Basically two ways</p> <ul> <li>top-down memoization: recursive way, but stores information when backtracking</li> <li>bottom up memorization: iterative way usually, going through all unique sub problems.</li> </ul> <p>DP is an example of <em>time-memory tradoff</em></p> <p>A DP approach runs in polynomial time when the number of distinct subproblems involved is polynomial in the input size and we can solve each such subproblem in polynomial time.</p> <p>In <strong>Bottom-up method</strong>, we sort the subproblems by size and solve them in size order, smallest first.</p> <p>In some cases, top-down method might be faster than bottom up solution, since some subproblems that the latter computed, might not be used in constructing final solution.</p> <h3 id="sub-problem-graph">Sub problem graph</h3> <p>Sub problem graph</p> <h2 id="152-parenthesis-matrix-chain-multiplication">15.2 Parenthesis Matrix Chain Multiplication</h2> <h2 id="my-thinking-after-these-two-examples">My thinking after these two examples:</h2> <h3 id="on-their-difference">On their difference:</h3> <ul> <li>Why rod cutting is cutting off one piece every time while matrix multiplication, splits the problem into two subproblems?</li> <li>What if each cut has a cost for <em>rod cutting</em></li> <li>What is the difference of their representation? Why <ul> <li>rod cutting only need to keep track of one index to identify the sub problem, while matrix multiplication, uses two indices to keep track of which problem is tracked.</li> <li>This indicates the space/time complexity of the solution</li> <li><strong>Representation of the problem determines the complexity of the problem</strong></li> </ul> </li> </ul> <h3 id="another-way-to-think-about-it">Another way to think about it:</h3> <p>The book gives us a quite standard way to think about this problem:</p> <ul> <li>Optimal structure of problems and subproblems, first break down the optimal problem into combination of smaller <strong>Independent</strong> optimal subproblems.</li> <li>Use spcae to assist computation, and reduce redundant compuation</li> </ul> <p>I am thinking may be we can think it in a different way, just for fun. When you are givin a optimization problem:</p> <ul> <li>first start off think from the smallest problems, base situations.</li> <li>Solve every base problems, and to see if you could, combine that information to build up a solution for second level problem.</li> <li>Keep going from there…</li> </ul> <p>This way of thinking follows the same step of the bottom up method:</p> <ul> <li>Rod - cutting, build a tabular that comtains all possible lengths, from the shortest possible, and grow one step at a time.</li> <li>Parenthesize Matrix Multiplication: Start off compute the cost of multiplying all matrix pairs, then triplets, then for consecutive matrixs…Each step built on the previous.</li> </ul> <p>Also, consider the all possible solution for these problems, the number of all possible solution is usually exponential, but by computing the small element and build the solution bottom up, will avoid overlapping compuatioin</p> <h3 id="greedy-aglorithms">Greedy Aglorithms</h3> <h3 id="amortized-analysis">Amortized Analysis</h3> <h2 id="advanced-data-structures">Advanced Data Structures</h2> <p>(trees Sets)</p> <h2 id="graph-algorithms">Graph Algorithms</h2> <h3 id="22-elementary-graph-algorithms">22 Elementary Graph Algorithms</h3> <h3 id="23-minimum-spanning-tree">23 Minimum Spanning Tree</h3> <h3 id="24-single-source-shortest-paths-643">24 Single-Source Shortest Paths 643</h3> <p>####24.1 The Bellman-Ford algorithm 651</p> <p>####24.2 Single-source shortest paths in directed acyclic graphs</p> <h4 id="243-dijkstras-algorithm-658">24.3 Dijkstra’s algorithm 658</h4> <p>####24.4 Difference constraints and shortest paths 664</p> <h4 id="245-proofs-of-shortest-paths-properties-671">24.5 Proofs of shortest-paths properties 671</h4> <h3 id="25-all-pairs-shortest-paths-684">25 All-Pairs Shortest Paths 684</h3> <h4 id="251-shortest-paths-and-matrix-multiplication">25.1 Shortest paths and matrix multiplication</h4> <h4 id="252-the-floyd-warshall-algorithm-693">25.2 The Floyd-Warshall algorithm 693</h4> <h4 id="253-johnsons-algorithm-for-sparse-graphs">25.3 Johnson’s algorithm for sparse graphs</h4> <h3 id="26-maximum-flow-708">26 Maximum Flow 708</h3> <h4 id="261-flow-networks-709">26.1 Flow networks 709</h4> <h4 id="262-the-ford-fulkerson-method-714">26.2 The Ford-Fulkerson method 714</h4> <h4 id="263-maximum-bipartite-matching-732">26.3 Maximum bipartite matching 732</h4> <h2 id="selected-topics">Selected Topics</h2>

Reading note for Introduction to Algorithms

2016-08-05T00:00:00+00:002016-08-05T00:00:00+00:00https://kevkeyingli.github.io/Angular-Service-and-Dependency-Injection<p>Service is an important design choice in angular 2, the idea is to keep components lean. Here I will cover what I learned about using service and dependency injection. A nice and more detailed resource to look at: https://angular.io/docs/ts/latest/guide/architecture.html</p> <h3 id="service">Service</h3> <ul> <li>Service is intended to provide service for component. To separate operational logic from component(so component can focus on controling the view)</li> <li>The code in <code class="language-plaintext highlighter-rouge">service.ts</code> file defines the <strong>service class</strong>, which acts as a prototype for service instances.</li> <li>The thing that is injected into components is <strong>service instance</strong>.</li> </ul> <h3 id="component">Component</h3> <ul> <li>responsible of defining and controling views, each view/tag can be considered as a <strong>component instance</strong></li> <li>In component, the <code class="language-plaintext highlighter-rouge">constructor</code> determines/specifies which service will be used.</li> <li>In the component constructor, we usually see <em>service instances</em>,<em>member variables</em>, ?(variable from other module? like child module?)</li> </ul> <h3 id="providers-array">Providers Array</h3> <ul> <li>To use a service in a component, we need to register the service as a service provider, so the <em>injector</em> will know how to create instances.</li> <li>Can register a service as a provider in mainly two ways: <ul> <li>register it in the provider array</li> <li>register when bootstrap</li> </ul> </li> <li>Provide different granuality/coverage</li> </ul> <h3 id="injector">Injector</h3> <ul> <li>Injector is used to <ul> <li>create/maintain service instances.</li> <li>According to the providers</li> <li>before the constructor of a component can be called</li> </ul> </li> <li>Additionally you need to import the service class in the component to use it.</li> </ul> <h3 id="to-use-a-service-in-a-component">To use a service in a component:</h3> <ul> <li>Import the service in the component</li> <li>Include it in the component’s provider array, or bootstrap the service already</li> <li>Declare a instance of the service in the constructor of the component, so each component can have a service instance.</li> </ul>Kevin

Service is an important design choice in angular 2, the idea is to keep components lean. Here I will cover what I learned about using service and dependency injection. A nice and more detailed resource to look at: https://angular.io/docs/ts/latest/guide/architecture.html

2016-07-22T00:00:00+00:002016-07-22T00:00:00+00:00https://kevkeyingli.github.io/Problems%20Questions%20and%20Solutions<p>I start this post in the idea of collecting and centralizing technical problems and questions that I have through my work and study. It is a place to revisit if similar problem re-occurs or some knowledge fades away. I will keep adding new things into here, as well as collect the scattered notes of the past.</p> <h1 id="keep-ssh-sessions-running-after-disconnection-and-resume-it-later">Keep SSH Sessions running after disconnection, and resume it later</h1> <p>from http://unix.stackexchange.com/questions/479/keep-ssh-sessions-running-after-disconnection?newreg=54f0dfa60fde4ed7881d617ab7a8a447</p> <ul> <li> <p>Use nohup to make your process ignore the hangup signal:</p> <p>$ nohup long-running-process &amp; $ exit</p> </li> <li> <p>You want to be using GNU Screen. It is super awesome!</p> <p>ssh me@myserver.com screen #start a screen session run-a-long-process</p> </li> </ul> <p>CTRL+a , d to detatch from your screen session</p> <div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>exit #disconnect from the server, while run-a-long-process continues When you come back to your laptop: ssh me@myserver.com screen -r #resume the screen session Then check out the progress of your long-running process! </code></pre></div></div> <p>screen is a very comprehensive tool, and can do a lot more than what I’ve described. While in a screen session, try ctrl+a,? to learn a few common commands. Probably the most common are:</p> <p>CTRL+a , c to create a new window CTRL+a , n to switch to the next window in your screen session CTRL+a , p to switch to the previous window in your screen session if you log in from a bunch of different systems, you may have accidentally left yourself attached to an active screen session on a different computer. for that reason, I always resume with screen -d -r to ensure that if another shell is attached to my screen session, it will be detached before I resume it on my current system.</p> <p>Other valuable answers: http://unix.stackexchange.com/questions/89483/keeping-a-process-running-after-putty-or-terminal-has-been-closed Screen Manual is here: https://www.gnu.org/software/screen/manual/screen.html</p>

I start this post in the idea of collecting and centralizing technical problems and questions that I have through my work and study. It is a place to revisit if similar problem re-occurs or some knowledge fades away. I will keep adding new things into here, as well as collect the scattered notes of the past.