From bd2f82680ae1aa428cdbecadb720f5650f888603 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Fri, 8 Sep 2017 22:36:32 +0100 Subject: [PATCH 01/98] Intial commit. Importing theme. --- .gitignore | 42 ++ 404.html | 10 + LICENSE.md | 9 + README.md | 134 ++++++ _config.yml | 20 + _includes/head.html | 29 ++ _includes/sidebar.html | 38 ++ _layouts/default.html | 47 ++ _layouts/page.html | 8 + _layouts/post.html | 25 ++ _posts/2013-12-31-whats-jekyll.md | 12 + _posts/2014-01-01-example-content.md | 122 +++++ _posts/2014-01-02-introducing-lanyon.md | 38 ++ about.md | 30 ++ atom.xml | 28 ++ index.html | 38 ++ public/apple-touch-icon-precomposed.png | Bin 0 -> 831 bytes public/css/lanyon.css | 563 ++++++++++++++++++++++++ public/css/poole.css | 430 ++++++++++++++++++ public/css/syntax.css | 65 +++ public/favicon.ico | Bin 0 -> 340 bytes 21 files changed, 1688 insertions(+) create mode 100644 .gitignore create mode 100644 404.html create mode 100644 LICENSE.md create mode 100644 README.md create mode 100644 _config.yml create mode 100644 _includes/head.html create mode 100644 _includes/sidebar.html create mode 100644 _layouts/default.html create mode 100644 _layouts/page.html create mode 100644 _layouts/post.html create mode 100644 _posts/2013-12-31-whats-jekyll.md create mode 100644 _posts/2014-01-01-example-content.md create mode 100644 _posts/2014-01-02-introducing-lanyon.md create mode 100644 about.md create mode 100644 atom.xml create mode 100644 index.html create mode 100644 public/apple-touch-icon-precomposed.png create mode 100644 public/css/lanyon.css create mode 100644 public/css/poole.css create mode 100644 public/css/syntax.css create mode 100644 public/favicon.ico diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..465cdb46 --- /dev/null +++ b/.gitignore @@ -0,0 +1,42 @@ +# Ignore docs files +_gh_pages +_site +.ruby-version + +# Numerous always-ignore extensions +*.diff +*.err +*.orig +*.log +*.rej +*.swo +*.swp +*.zip +*.vi +*~ + +# OS or Editor folders +.DS_Store +._* +Thumbs.db +.cache +.project +.settings +.tmproj +*.esproj +nbproject +*.sublime-project +*.sublime-workspace +.idea + +# Komodo +*.komodoproject +.komodotools + +# grunt-html-validation +validation-status.json +validation-report.json + +# Folders to ignore +node_modules +bower_components diff --git a/404.html b/404.html new file mode 100644 index 00000000..4bf3f7d8 --- /dev/null +++ b/404.html @@ -0,0 +1,10 @@ +--- +layout: default +title: "404: Page not found" +permalink: 404.html +--- + +
+

404: Page not found

+

Sorry, we've misplaced that URL or it's pointing to something that doesn't exist. Head back home to try finding it again.

+
diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 00000000..af1b0ec7 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,9 @@ +# Released under MIT License + +Copyright (c) 2014 Mark Otto. + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 00000000..b6c7d402 --- /dev/null +++ b/README.md @@ -0,0 +1,134 @@ +# Lanyon + +Lanyon is an unassuming [Jekyll](http://jekyllrb.com) theme that places content first by tucking away navigation in a hidden drawer. It's based on [Poole](http://getpoole.com), the Jekyll butler. + +![Lanyon](https://f.cloud.github.com/assets/98681/1825266/be03f014-71b0-11e3-9539-876e61530e24.png) +![Lanyon with open sidebar](https://f.cloud.github.com/assets/98681/1825267/be04a914-71b0-11e3-966f-8afe9894c729.png) + + +## Contents + +- [Usage](#usage) +- [Options](#options) + - [Sidebar menu](#sidebar-menu) + - [Themes](#themes) + - [Reverse layout](#reverse-layout) +- [Development](#development) +- [Author](#author) +- [License](#license) + + +## Usage + +Lanyon is a theme built on top of [Poole](https://github.com/poole/poole), which provides a fully furnished Jekyll setup—just download and start the Jekyll server. See [the Poole usage guidelines](https://github.com/poole/poole#usage) for how to install and use Jekyll. + + +## Options + +Lanyon includes some customizable options, typically applied via classes on the `` element. + + +### Sidebar menu + +Create a list of nav links in the sidebar by assigning each Jekyll page the correct layout in the page's [front-matter](http://jekyllrb.com/docs/frontmatter/). + +``` +--- +layout: page +title: About +--- +``` + +**Why require a specific layout?** Jekyll will return *all* pages, including the `atom.xml`, and with an alphabetical sort order. To ensure the first link is *Home*, we exclude the `index.html` page from this list by specifying the `page` layout. + + +### Themes + +Lanyon ships with eight optional themes based on the [base16 color scheme](https://github.com/chriskempson/base16). Apply a theme to change the color scheme (mostly applies to sidebar and links). + +![Lanyon with red theme](https://f.cloud.github.com/assets/98681/1825270/be065110-71b0-11e3-9ed8-9b8de753a4af.png) +![Lanyon with red theme and open sidebar](https://f.cloud.github.com/assets/98681/1825269/be05ec20-71b0-11e3-91ea-a9138ef07186.png) + +There are eight themes available at this time. + +![Available theme classes](https://f.cloud.github.com/assets/98681/1817044/e5b0ec06-6f68-11e3-83d7-acd1942797a1.png) + +To use a theme, add any one of the available theme classes to the `` element in the `default.html` layout, like so: + +```html + + ... + +``` + +To create your own theme, look to the Themes section of [included CSS file](https://github.com/poole/lanyon/blob/master/public/css/lanyon.css). Copy any existing theme (they're only a few lines of CSS), rename it, and change the provided colors. + + +### Reverse layout + +![Lanyon with reverse layout](https://f.cloud.github.com/assets/98681/1825265/be03f2e4-71b0-11e3-89f1-360705524495.png) +![Lanyon with reverse layout and open sidebar](https://f.cloud.github.com/assets/98681/1825268/be056174-71b0-11e3-88c8-5055bca4307f.png) + +Reverse the page orientation with a single class. + +```html + + ... + +``` + + +### Sidebar overlay instead of push + +Make the sidebar overlap the viewport content with a single class: + +```html + + ... + +``` + +This will keep the content stationary and slide in the sidebar over the side content. It also adds a `box-shadow` based outline to the toggle for contrast against backgrounds, as well as a `box-shadow` on the sidebar for depth. + +It's also available for a reversed layout when you add both classes: + +```html + + ... + +``` + +### Sidebar open on page load + +Show an open sidebar on page load by modifying the `` tag within the `sidebar.html` layout to add the `checked` boolean attribute: + +```html + +``` + +Using Liquid you can also conditionally show the sidebar open on a per-page basis. For example, here's how you could have it open on the homepage only: + +```html + +``` + +## Development + +Lanyon has two branches, but only one is used for active development. + +- `master` for development. **All pull requests should be to submitted against `master`.** +- `gh-pages` for our hosted site, which includes our analytics tracking code. **Please avoid using this branch.** + + +## Author + +**Mark Otto** +- +- + + +## License + +Open sourced under the [MIT license](LICENSE.md). + +<3 diff --git a/_config.yml b/_config.yml new file mode 100644 index 00000000..26efddf7 --- /dev/null +++ b/_config.yml @@ -0,0 +1,20 @@ +# Permalinks +# +# Use of `relative_permalinks` ensures post links from the index work properly. +permalink: pretty + +# Setup +title: Lanyon +tagline: 'A Jekyll theme' +description: 'A reserved Jekyll theme that places the utmost gravity on content with a hidden drawer. Made by @mdo.' +url: http://lanyon.getpoole.com +baseurl: '' + +# About/contact +author: + name: Mark Otto + url: https://twitter.com/mdo + email: markdotto@gmail.com + +# Custom vars +version: 1.0.0 diff --git a/_includes/head.html b/_includes/head.html new file mode 100644 index 00000000..1948f301 --- /dev/null +++ b/_includes/head.html @@ -0,0 +1,29 @@ + + + + + + + + + + {% if page.title == "Home" %} + {{ site.title }} · {{ site.tagline }} + {% else %} + {{ page.title }} · {{ site.title }} + {% endif %} + + + + + + + + + + + + + + + diff --git a/_includes/sidebar.html b/_includes/sidebar.html new file mode 100644 index 00000000..520eebaf --- /dev/null +++ b/_includes/sidebar.html @@ -0,0 +1,38 @@ + + + + + diff --git a/_layouts/default.html b/_layouts/default.html new file mode 100644 index 00000000..e1ad606e --- /dev/null +++ b/_layouts/default.html @@ -0,0 +1,47 @@ + + + + {% include head.html %} + + + + {% include sidebar.html %} + + +
+
+
+

+ {{ site.title }} + {{ site.tagline }} +

+
+
+ +
+ {{ content }} +
+
+ + + + + + diff --git a/_layouts/page.html b/_layouts/page.html new file mode 100644 index 00000000..4e0d4ebf --- /dev/null +++ b/_layouts/page.html @@ -0,0 +1,8 @@ +--- +layout: default +--- + +
+

{{ page.title }}

+ {{ content }} +
diff --git a/_layouts/post.html b/_layouts/post.html new file mode 100644 index 00000000..c0274776 --- /dev/null +++ b/_layouts/post.html @@ -0,0 +1,25 @@ +--- +layout: default +--- + +
+

{{ page.title }}

+ {{ page.date | date_to_string }} + {{ content }} +
+ +
+

Related Posts

+ +
diff --git a/_posts/2013-12-31-whats-jekyll.md b/_posts/2013-12-31-whats-jekyll.md new file mode 100644 index 00000000..6bf2b50d --- /dev/null +++ b/_posts/2013-12-31-whats-jekyll.md @@ -0,0 +1,12 @@ +--- +layout: post +title: What's Jekyll? +--- + +[Jekyll](http://jekyllrb.com) is a static site generator, an open-source tool for creating simple yet powerful websites of all shapes and sizes. From [the project's readme](https://github.com/mojombo/jekyll/blob/master/README.markdown): + + > Jekyll is a simple, blog aware, static site generator. It takes a template directory [...] and spits out a complete, static website suitable for serving with Apache or your favorite web server. This is also the engine behind GitHub Pages, which you can use to host your project’s page or blog right here from GitHub. + +It's an immensely useful tool and one we encourage you to use here with Lanyon. + +Find out more by [visiting the project on GitHub](https://github.com/mojombo/jekyll). diff --git a/_posts/2014-01-01-example-content.md b/_posts/2014-01-01-example-content.md new file mode 100644 index 00000000..81e47487 --- /dev/null +++ b/_posts/2014-01-01-example-content.md @@ -0,0 +1,122 @@ +--- +layout: post +title: Example content +--- + + +
+ Howdy! This is an example blog post that shows several types of HTML content supported in this theme. +
+ +Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. *Aenean eu leo quam.* Pellentesque ornare sem lacinia quam venenatis vestibulum. Sed posuere consectetur est at lobortis. Cras mattis consectetur purus sit amet fermentum. + +> Curabitur blandit tempus porttitor. Nullam quis risus eget urna mollis ornare vel eu leo. Nullam id dolor id nibh ultricies vehicula ut id elit. + +Etiam porta **sem malesuada magna** mollis euismod. Cras mattis consectetur purus sit amet fermentum. Aenean lacinia bibendum nulla sed consectetur. + +## Inline HTML elements + +HTML defines a long list of available inline tags, a complete list of which can be found on the [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/HTML/Element). + +- **To bold text**, use ``. +- *To italicize text*, use ``. +- Abbreviations, like HTML should use ``, with an optional `title` attribute for the full phrase. +- Citations, like — Mark otto, should use ``. +- Deleted text should use `` and inserted text should use ``. +- Superscript text uses `` and subscript text uses ``. + +Most of these elements are styled by browsers with few modifications on our part. + +## Heading + +Vivamus sagittis lacus vel augue rutrum faucibus dolor auctor. Duis mollis, est non commodo luctus, nisi erat porttitor ligula, eget lacinia odio sem nec elit. Morbi leo risus, porta ac consectetur ac, vestibulum at eros. + +### Code + +Cum sociis natoque penatibus et magnis dis `code element` montes, nascetur ridiculus mus. + +{% highlight js %} +// Example can be run directly in your JavaScript console + +// Create a function that takes two arguments and returns the sum of those arguments +var adder = new Function("a", "b", "return a + b"); + +// Call the function +adder(2, 6); +// > 8 +{% endhighlight %} + +Aenean lacinia bibendum nulla sed consectetur. Etiam porta sem malesuada magna mollis euismod. Fusce dapibus, tellus ac cursus commodo, tortor mauris condimentum nibh, ut fermentum massa. + +### Lists + +Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Aenean lacinia bibendum nulla sed consectetur. Etiam porta sem malesuada magna mollis euismod. Fusce dapibus, tellus ac cursus commodo, tortor mauris condimentum nibh, ut fermentum massa justo sit amet risus. + +* Praesent commodo cursus magna, vel scelerisque nisl consectetur et. +* Donec id elit non mi porta gravida at eget metus. +* Nulla vitae elit libero, a pharetra augue. + +Donec ullamcorper nulla non metus auctor fringilla. Nulla vitae elit libero, a pharetra augue. + +1. Vestibulum id ligula porta felis euismod semper. +2. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. +3. Maecenas sed diam eget risus varius blandit sit amet non magna. + +Cras mattis consectetur purus sit amet fermentum. Sed posuere consectetur est at lobortis. + +
+
HyperText Markup Language (HTML)
+
The language used to describe and define the content of a Web page
+ +
Cascading Style Sheets (CSS)
+
Used to describe the appearance of Web content
+ +
JavaScript (JS)
+
The programming language used to build advanced Web sites and applications
+
+ +Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Morbi leo risus, porta ac consectetur ac, vestibulum at eros. Nullam quis risus eget urna mollis ornare vel eu leo. + +### Tables + +Aenean lacinia bibendum nulla sed consectetur. Lorem ipsum dolor sit amet, consectetur adipiscing elit. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
NameUpvotesDownvotes
Totals2123
Alice1011
Bob43
Charlie79
+ +Nullam id dolor id nibh ultricies vehicula ut id elit. Sed posuere consectetur est at lobortis. Nullam quis risus eget urna mollis ornare vel eu leo. + +----- + +Want to see something else added? Open an issue. diff --git a/_posts/2014-01-02-introducing-lanyon.md b/_posts/2014-01-02-introducing-lanyon.md new file mode 100644 index 00000000..13e7ce48 --- /dev/null +++ b/_posts/2014-01-02-introducing-lanyon.md @@ -0,0 +1,38 @@ +--- +layout: post +title: Introducing Lanyon +--- + +Lanyon is an unassuming [Jekyll](http://jekyllrb.com) theme that places content first by tucking away navigation in a hidden drawer. It's based on [Poole](http://getpoole.com), the Jekyll butler. + +### Built on Poole + +Poole is the Jekyll Butler, serving as an upstanding and effective foundation for Jekyll themes by [@mdo](https://twitter.com/mdo). Poole, and every theme built on it (like Lanyon here) includes the following: + +* Complete Jekyll setup included (layouts, config, [404](/404), [RSS feed](/atom.xml), posts, and [example page](/about)) +* Mobile friendly design and development +* Easily scalable text and component sizing with `rem` units in the CSS +* Support for a wide gamut of HTML elements +* Related posts (time-based, because Jekyll) below each post +* Syntax highlighting, courtesy Pygments (the Python-based code snippet highlighter) + +### Lanyon features + +In addition to the features of Poole, Lanyon adds the following: + +* Toggleable sliding sidebar (built with only CSS) via **☰** link in top corner +* Sidebar includes support for textual modules and a dynamically generated navigation with active link support +* Two orientations for content and sidebar, default (left sidebar) and [reverse](https://github.com/poole/lanyon#reverse-layout) (right sidebar), available via `` classes +* [Eight optional color schemes](https://github.com/poole/lanyon#themes), available via `` classes + +[Head to the readme](https://github.com/poole/lanyon#readme) to learn more. + +### Browser support + +Lanyon is by preference a forward-thinking project. In addition to the latest versions of Chrome, Safari (mobile and desktop), and Firefox, it is only compatible with Internet Explorer 9 and above. + +### Download + +Lanyon is developed on and hosted with GitHub. Head to the GitHub repository for downloads, bug reports, and features requests. + +Thanks! diff --git a/about.md b/about.md new file mode 100644 index 00000000..9b2605bb --- /dev/null +++ b/about.md @@ -0,0 +1,30 @@ +--- +layout: page +title: About +--- + +

+ Hey there! This page is included as an example. Feel free to customize it for your own use upon downloading. Carry on! +

+ +In the novel, *The Strange Case of Dr. Jeykll and Mr. Hyde*, Mr. Poole is Dr. Jekyll's virtuous and loyal butler. Similarly, Poole is an upstanding and effective butler that helps you build Jekyll themes. It's made by [@mdo](https://twitter.com/mdo). + +There are currently two themes built on Poole: + +* [Hyde](http://hyde.getpoole.com) +* [Lanyon](http://lanyon.getpoole.com) + +Learn more and contribute on [GitHub](https://github.com/poole). + +## Setup + +Some fun facts about the setup of this project include: + +* Built for [Jekyll](http://jekyllrb.com) +* Developed on GitHub and hosted for free on [GitHub Pages](https://pages.github.com) +* Coded with [Sublime Text 2](http://sublimetext.com), an amazing code editor +* Designed and developed while listening to music like [Blood Bros Trilogy](https://soundcloud.com/maddecent/sets/blood-bros-series) + +Have questions or suggestions? Feel free to [open an issue on GitHub](https://github.com/poole/issues/new) or [ask me on Twitter](https://twitter.com/mdo). + +Thanks for reading! diff --git a/atom.xml b/atom.xml new file mode 100644 index 00000000..15eed6ca --- /dev/null +++ b/atom.xml @@ -0,0 +1,28 @@ +--- +layout: null +--- + + + + + {{ site.title }} + + + {{ site.time | date_to_xmlschema }} + {{ site.url }} + + {{ site.author.name }} + {{ site.author.email }} + + + {% for post in site.posts %} + + {{ post.title }} + + {{ post.date | date_to_xmlschema }} + {{ site.url }}{{ site.baseurl }}{{ post.id }} + {{ post.content | xml_escape }} + + {% endfor %} + + diff --git a/index.html b/index.html new file mode 100644 index 00000000..e4c52988 --- /dev/null +++ b/index.html @@ -0,0 +1,38 @@ +--- +layout: default +title: Home +--- + +
+ {% for post in paginator.posts %} +
+

+ + {{ post.title }} + +

+ + {{ post.date | date_to_string }} + + {{ post.content }} +
+ {% endfor %} +
+ + + diff --git a/public/apple-touch-icon-precomposed.png b/public/apple-touch-icon-precomposed.png new file mode 100644 index 0000000000000000000000000000000000000000..6cb41a8e552c6150fe56b3e7dec516fb20093793 GIT binary patch literal 831 zcmeAS@N?(olHy`uVBq!ia0vp^GeDSw2}n*~u)PdONtU=qlmzFem6RtIr7}3C&;z9@5zNS2R@25`Asfh;AKnX+Na7u<97pKfq@h3WR^mA`88 z?UHTy&$mDSZ(}bLt#tR^R^N;HyMq~m6j*~49J!V_aH)7Sih$4rCd~;tYEVtKwv^Ph03*mqU=WF?`)+l_csf7$lbVq?eg8ZCriHZf0dPmchuUsuf3nV1IIRN=fxMh6GLk=k zZMu23Znx5OYaSz`-ky294+9(jy#Dy{%!v)95ooLJGzi`&*fMKaA}@awOyN0x{Ma$D%Ixgb7d1FHF+EN3U!RoRfdo7Gf15=v@yE0Bi`VYm+j?lDea(>@8y@Wa|LNPOtgI}ipL>obxb$mz>>h)i?~)gFJvr>RGNdW-kATMnuF%es z>gk&wbfKpkRv}<|f(1S}JwXE>EPm?sYzAfquV*D64qq{42j&O{Pgg&ebxsLQ0K4yS AE&u=k literal 0 HcmV?d00001 diff --git a/public/css/lanyon.css b/public/css/lanyon.css new file mode 100644 index 00000000..1d57108e --- /dev/null +++ b/public/css/lanyon.css @@ -0,0 +1,563 @@ +/* + * ___ + * /\_ \ + * \//\ \ __ ___ __ __ ___ ___ + * \ \ \ /'__`\ /' _ `\/\ \/\ \ / __`\ /' _ `\ + * \_\ \_/\ \_\.\_/\ \/\ \ \ \_\ \/\ \_\ \/\ \/\ \ + * /\____\ \__/.\_\ \_\ \_\/`____ \ \____/\ \_\ \_\ + * \/____/\/__/\/_/\/_/\/_/`/___/> \/___/ \/_/\/_/ + * /\___/ + * \/__/ + * + * Designed, built, and released under MIT license by @mdo. Learn more at + * https://github.com/poole/lanyon. + */ + + +/* + * Contents + * + * Global resets + * Masthead + * Sidebar + * Slide effect + * Posts and pages + * Pagination + * Reverse layout + * Themes + */ + + +/* + * Global resets + * + * Update the foundational and global aspects of the page. + */ + +/* Prevent scroll on narrow devices */ +html, +body { + overflow-x: hidden; +} + +html { + font-family: "PT Serif", Georgia, "Times New Roman", serif; +} + +h1, h2, h3, h4, h5, h6 { + font-family: "PT Sans", Helvetica, Arial, sans-serif; + font-weight: 400; + color: #313131; + letter-spacing: -.025rem; +} + + +/* + * Wrapper + * + * The wrapper is used to position site content when the sidebar is toggled. We + * use an outter wrap to position the sidebar without interferring with the + * regular page content. + */ + +.wrap { + position: relative; + width: 100%; +} + + +/* + * Container + * + * Center the page content. + */ + +.container { + max-width: 28rem; +} +@media (min-width: 38em) { + .container { + max-width: 32rem; + } +} +@media (min-width: 56em) { + .container { + max-width: 38rem; + } +} + + +/* + * Masthead + * + * Super small header above the content for site name and short description. + */ + +.masthead { + padding-top: 1rem; + padding-bottom: 1rem; + margin-bottom: 3rem; + border-bottom: 1px solid #eee; +} +.masthead-title { + margin-top: 0; + margin-bottom: 0; + color: #505050; +} +.masthead-title a { + color: #505050; +} +.masthead-title small { + font-size: 75%; + font-weight: 400; + color: #c0c0c0; + letter-spacing: 0; +} + +@media (max-width: 48em) { + .masthead-title { + text-align: center; + } + .masthead-title small { + display: none; + } +} + + +/* + * Sidebar + * + * The sidebar is the drawer, the item we are toggling with our handy hamburger + * button in the corner of the page. + * + * This particular sidebar implementation was inspired by Chris Coyier's + * "Offcanvas Menu with CSS Target" article, and the checkbox variation from the + * comments by a reader. It modifies both implementations to continue using the + * checkbox (no change in URL means no polluted browser history), but this uses + * `position` for the menu to avoid some potential content reflow issues. + * + * Source: http://css-tricks.com/off-canvas-menu-with-css-target/#comment-207504 + */ + +/* Style and "hide" the sidebar */ +.sidebar { + position: fixed; + top: 0; + bottom: 0; + left: -14rem; + width: 14rem; + visibility: hidden; + overflow-y: auto; + font-family: "PT Sans", Helvetica, Arial, sans-serif; + font-size: .875rem; /* 15px */ + color: rgba(255,255,255,.6); + background-color: #202020; + -webkit-transition: all .3s ease-in-out; + transition: all .3s ease-in-out; +} +@media (min-width: 30em) { + .sidebar { + font-size: .75rem; /* 14px */ + } +} + +/* Sidebar content */ +.sidebar a { + font-weight: normal; + color: #fff; +} +.sidebar-item { + padding: 1rem; +} +.sidebar-item p:last-child { + margin-bottom: 0; +} + +/* Sidebar nav */ +.sidebar-nav { + border-bottom: 1px solid rgba(255,255,255,.1); +} +.sidebar-nav-item { + display: block; + padding: .5rem 1rem; + border-top: 1px solid rgba(255,255,255,.1); +} +.sidebar-nav-item.active, +a.sidebar-nav-item:hover, +a.sidebar-nav-item:focus { + text-decoration: none; + background-color: rgba(255,255,255,.1); + border-color: transparent; +} + +@media (min-width: 48em) { + .sidebar-item { + padding: 1.5rem; + } + .sidebar-nav-item { + padding-left: 1.5rem; + padding-right: 1.5rem; + } +} + +/* Hide the sidebar checkbox that we toggle with `.sidebar-toggle` */ +.sidebar-checkbox { + position: absolute; + opacity: 0; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; +} + +/* Style the `label` that we use to target the `.sidebar-checkbox` */ +.sidebar-toggle { + position: absolute; + top: .8rem; + left: 1rem; + display: block; + padding: .25rem .75rem; + color: #505050; + background-color: #fff; + border-radius: .25rem; + cursor: pointer; +} + +.sidebar-toggle:before { + display: inline-block; + width: 1rem; + height: .75rem; + content: ""; + background-image: -webkit-linear-gradient(to bottom, #555, #555 20%, #fff 20%, #fff 40%, #555 40%, #555 60%, #fff 60%, #fff 80%, #555 80%, #555 100%); + background-image: -moz-linear-gradient(to bottom, #555, #555 20%, #fff 20%, #fff 40%, #555 40%, #555 60%, #fff 60%, #fff 80%, #555 80%, #555 100%); + background-image: -ms-linear-gradient(to bottom, #555, #555 20%, #fff 20%, #fff 40%, #555 40%, #555 60%, #fff 60%, #fff 80%, #555 80%, #555 100%); + background-image: linear-gradient(to bottom, #555, #555 20%, #fff 20%, #fff 40%, #555 40%, #555 60%, #fff 60%, #fff 80%, #555 80%, #555 100%); +} + +.sidebar-toggle:active, +#sidebar-checkbox:focus ~ .sidebar-toggle, +#sidebar-checkbox:checked ~ .sidebar-toggle { + color: #fff; + background-color: #555; +} + +.sidebar-toggle:active:before, +#sidebar-checkbox:focus ~ .sidebar-toggle:before, +#sidebar-checkbox:checked ~ .sidebar-toggle:before { + background-image: -webkit-linear-gradient(to bottom, #fff, #fff 20%, #555 20%, #555 40%, #fff 40%, #fff 60%, #555 60%, #555 80%, #fff 80%, #fff 100%); + background-image: -moz-linear-gradient(to bottom, #fff, #fff 20%, #555 20%, #555 40%, #fff 40%, #fff 60%, #555 60%, #555 80%, #fff 80%, #fff 100%); + background-image: -ms-linear-gradient(to bottom, #fff, #fff 20%, #555 20%, #555 40%, #fff 40%, #fff 60%, #555 60%, #555 80%, #fff 80%, #fff 100%); + background-image: linear-gradient(to bottom, #fff, #fff 20%, #555 20%, #555 40%, #fff 40%, #fff 60%, #555 60%, #555 80%, #fff 80%, #fff 100%); +} + +@media (min-width: 30.1em) { + .sidebar-toggle { + position: fixed; + } +} + +@media print { + .sidebar-toggle { + display: none; + } +} + +/* Slide effect + * + * Handle the sliding effects of the sidebar and content in one spot, seperate + * from the default styles. + * + * As an a heads up, we don't use `transform: translate3d()` here because when + * mixed with `position: fixed;` for the sidebar toggle, it creates a new + * containing block. Put simply, the fixed sidebar toggle behaves like + * `position: absolute;` when transformed. + * + * Read more about it at http://meyerweb.com/eric/thoughts/2011/09/12/. + */ + +.wrap, +.sidebar, +.sidebar-toggle { + -webkit-backface-visibility: hidden; + -ms-backface-visibility: hidden; + backface-visibility: hidden; +} +.wrap, +.sidebar-toggle { + -webkit-transition: -webkit-transform .3s ease-in-out; + transition: transform .3s ease-in-out; +} + +#sidebar-checkbox:checked + .sidebar { + z-index: 10; + visibility: visible; +} +#sidebar-checkbox:checked ~ .sidebar, +#sidebar-checkbox:checked ~ .wrap, +#sidebar-checkbox:checked ~ .sidebar-toggle { + -webkit-transform: translateX(14rem); + -ms-transform: translateX(14rem); + transform: translateX(14rem); +} + + +/* + * Posts and pages + * + * Each post is wrapped in `.post` and is used on default and post layouts. Each + * page is wrapped in `.page` and is only used on the page layout. + */ + +.page, +.post { + margin-bottom: 4em; +} + +/* Blog post or page title */ +.page-title, +.post-title, +.post-title a { + color: #303030; +} +.page-title, +.post-title { + margin-top: 0; +} + +/* Meta data line below post title */ +.post-date { + display: block; + margin-top: -.5rem; + margin-bottom: 1rem; + color: #9a9a9a; +} + +/* Related posts */ +.related { + padding-top: 2rem; + padding-bottom: 2rem; + border-top: 1px solid #eee; +} +.related-posts { + padding-left: 0; + list-style: none; +} +.related-posts h3 { + margin-top: 0; +} +.related-posts li small { + font-size: 75%; + color: #999; +} +.related-posts li a:hover { + color: #268bd2; + text-decoration: none; +} +.related-posts li a:hover small { + color: inherit; +} + + +/* + * Pagination + * + * Super lightweight (HTML-wise) blog pagination. `span`s are provide for when + * there are no more previous or next posts to show. + */ + +.pagination { + overflow: hidden; /* clearfix */ + margin-left: -1rem; + margin-right: -1rem; + font-family: "PT Sans", Helvetica, Arial, sans-serif; + color: #ccc; + text-align: center; +} + +/* Pagination items can be `span`s or `a`s */ +.pagination-item { + display: block; + padding: 1rem; + border: 1px solid #eee; +} +.pagination-item:first-child { + margin-bottom: -1px; +} + +/* Only provide a hover state for linked pagination items */ +a.pagination-item:hover { + background-color: #f5f5f5; +} + +@media (min-width: 30em) { + .pagination { + margin: 3rem 0; + } + .pagination-item { + float: left; + width: 50%; + } + .pagination-item:first-child { + margin-bottom: 0; + border-top-left-radius: 4px; + border-bottom-left-radius: 4px; + } + .pagination-item:last-child { + margin-left: -1px; + border-top-right-radius: 4px; + border-bottom-right-radius: 4px; + } +} + + +/* + * Reverse layout + * + * Flip the orientation of the page by placing the `.sidebar` and sidebar toggle + * on the right side. + */ + +.layout-reverse .sidebar { + left: auto; + right: -14rem; +} +.layout-reverse .sidebar-toggle { + left: auto; + right: 1rem; +} + +.layout-reverse #sidebar-checkbox:checked ~ .sidebar, +.layout-reverse #sidebar-checkbox:checked ~ .wrap, +.layout-reverse #sidebar-checkbox:checked ~ .sidebar-toggle { + -webkit-transform: translateX(-14rem); + -ms-transform: translateX(-14rem); + transform: translateX(-14rem); +} + + +/* + * Themes + * + * Apply custom color schemes by adding the appropriate class to the `body`. + * Based on colors from Base16: http://chriskempson.github.io/base16/#default. + */ + +/* Red */ +.theme-base-08 .sidebar, +.theme-base-08 .sidebar-toggle:active, +.theme-base-08 #sidebar-checkbox:checked ~ .sidebar-toggle { + background-color: #ac4142; +} +.theme-base-08 .container a, +.theme-base-08 .sidebar-toggle, +.theme-base-08 .related-posts li a:hover { + color: #ac4142; +} + +/* Orange */ +.theme-base-09 .sidebar, +.theme-base-09 .sidebar-toggle:active, +.theme-base-09 #sidebar-checkbox:checked ~ .sidebar-toggle { + background-color: #d28445; +} +.theme-base-09 .container a, +.theme-base-09 .sidebar-toggle, +.theme-base-09 .related-posts li a:hover { + color: #d28445; +} + +/* Yellow */ +.theme-base-0a .sidebar, +.theme-base-0a .sidebar-toggle:active, +.theme-base-0a #sidebar-checkbox:checked ~ .sidebar-toggle { + background-color: #f4bf75; +} +.theme-base-0a .container a, +.theme-base-0a .sidebar-toggle, +.theme-base-0a .related-posts li a:hover { + color: #f4bf75; +} + +/* Green */ +.theme-base-0b .sidebar, +.theme-base-0b .sidebar-toggle:active, +.theme-base-0b #sidebar-checkbox:checked ~ .sidebar-toggle { + background-color: #90a959; +} +.theme-base-0b .container a, +.theme-base-0b .sidebar-toggle, +.theme-base-0b .related-posts li a:hover { + color: #90a959; +} + +/* Cyan */ +.theme-base-0c .sidebar, +.theme-base-0c .sidebar-toggle:active, +.theme-base-0c #sidebar-checkbox:checked ~ .sidebar-toggle { + background-color: #75b5aa; +} +.theme-base-0c .container a, +.theme-base-0c .sidebar-toggle, +.theme-base-0c .related-posts li a:hover { + color: #75b5aa; +} + +/* Blue */ +.theme-base-0d .sidebar, +.theme-base-0d .sidebar-toggle:active, +.theme-base-0d #sidebar-checkbox:checked ~ .sidebar-toggle { + background-color: #6a9fb5; +} +.theme-base-0d .container a, +.theme-base-0d .sidebar-toggle, +.theme-base-0d .related-posts li a:hover { + color: #6a9fb5; +} + +/* Magenta */ +.theme-base-0e .sidebar, +.theme-base-0e .sidebar-toggle:active, +.theme-base-0e #sidebar-checkbox:checked ~ .sidebar-toggle { + background-color: #aa759f; +} +.theme-base-0e .container a, +.theme-base-0e .sidebar-toggle, +.theme-base-0e .related-posts li a:hover { + color: #aa759f; +} + +/* Brown */ +.theme-base-0f .sidebar, +.theme-base-0f .sidebar-toggle:active, +.theme-base-0f #sidebar-checkbox:checked ~ .sidebar-toggle { + background-color: #8f5536; +} +.theme-base-0f .container a, +.theme-base-0f .sidebar-toggle, +.theme-base-0f .related-posts li a:hover { + color: #8f5536; +} + + +/* + * Overlay sidebar + * + * Make the sidebar content overlay the viewport content instead of pushing it + * aside when toggled. + */ + +.sidebar-overlay #sidebar-checkbox:checked ~ .wrap { + -webkit-transform: translateX(0); + -ms-transform: translateX(0); + transform: translateX(0); +} +.sidebar-overlay #sidebar-checkbox:checked ~ .sidebar-toggle { + box-shadow: 0 0 0 .25rem #fff; +} +.sidebar-overlay #sidebar-checkbox:checked ~ .sidebar { + box-shadow: .25rem 0 .5rem rgba(0,0,0,.1); +} + +/* Only one tweak for a reverse layout */ +.layout-reverse.sidebar-overlay #sidebar-checkbox:checked ~ .sidebar { + box-shadow: -.25rem 0 .5rem rgba(0,0,0,.1); +} diff --git a/public/css/poole.css b/public/css/poole.css new file mode 100644 index 00000000..8ec27e7a --- /dev/null +++ b/public/css/poole.css @@ -0,0 +1,430 @@ +/* + * ___ + * /\_ \ + * _____ ___ ___\//\ \ __ + * /\ '__`\ / __`\ / __`\\ \ \ /'__`\ + * \ \ \_\ \/\ \_\ \/\ \_\ \\_\ \_/\ __/ + * \ \ ,__/\ \____/\ \____//\____\ \____\ + * \ \ \/ \/___/ \/___/ \/____/\/____/ + * \ \_\ + * \/_/ + * + * Designed, built, and released under MIT license by @mdo. Learn more at + * https://github.com/poole/poole. + */ + + +/* + * Contents + * + * Body resets + * Custom type + * Messages + * Container + * Masthead + * Posts and pages + * Pagination + * Reverse layout + * Themes + */ + + +/* + * Body resets + * + * Update the foundational and global aspects of the page. + */ + +* { + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} + +html, +body { + margin: 0; + padding: 0; +} + +html { + font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; + font-size: 16px; + line-height: 1.5; +} +@media (min-width: 38em) { + html { + font-size: 20px; + } +} + +body { + color: #515151; + background-color: #fff; + -webkit-text-size-adjust: 100%; + -ms-text-size-adjust: 100%; +} + +/* No `:visited` state is required by default (browsers will use `a`) */ +a { + color: #268bd2; + text-decoration: none; +} +a strong { + color: inherit; +} +/* `:focus` is linked to `:hover` for basic accessibility */ +a:hover, +a:focus { + text-decoration: underline; +} + +/* Headings */ +h1, h2, h3, h4, h5, h6 { + margin-bottom: .5rem; + font-weight: bold; + line-height: 1.25; + color: #313131; + text-rendering: optimizeLegibility; +} +h1 { + font-size: 2rem; +} +h2 { + margin-top: 1rem; + font-size: 1.5rem; +} +h3 { + margin-top: 1.5rem; + font-size: 1.25rem; +} +h4, h5, h6 { + margin-top: 1rem; + font-size: 1rem; +} + +/* Body text */ +p { + margin-top: 0; + margin-bottom: 1rem; +} + +strong { + color: #303030; +} + + +/* Lists */ +ul, ol, dl { + margin-top: 0; + margin-bottom: 1rem; +} + +dt { + font-weight: bold; +} +dd { + margin-bottom: .5rem; +} + +/* Misc */ +hr { + position: relative; + margin: 1.5rem 0; + border: 0; + border-top: 1px solid #eee; + border-bottom: 1px solid #fff; +} + +abbr { + font-size: 85%; + font-weight: bold; + color: #555; + text-transform: uppercase; +} +abbr[title] { + cursor: help; + border-bottom: 1px dotted #e5e5e5; +} + +/* Code */ +code, +pre { + font-family: Menlo, Monaco, "Courier New", monospace; +} +code { + padding: .25em .5em; + font-size: 85%; + color: #bf616a; + background-color: #f9f9f9; + border-radius: 3px; +} +pre { + display: block; + margin-top: 0; + margin-bottom: 1rem; + padding: 1rem; + font-size: .8rem; + line-height: 1.4; + white-space: pre; + white-space: pre-wrap; + word-break: break-all; + word-wrap: break-word; + background-color: #f9f9f9; +} +pre code { + padding: 0; + font-size: 100%; + color: inherit; + background-color: transparent; +} + +/* Pygments via Jekyll */ +.highlight { + margin-bottom: 1rem; + border-radius: 4px; +} +.highlight pre { + margin-bottom: 0; +} + +/* Gist via GitHub Pages */ +.gist .gist-file { + font-family: Menlo, Monaco, "Courier New", monospace !important; +} +.gist .markdown-body { + padding: 15px; +} +.gist pre { + padding: 0; + background-color: transparent; +} +.gist .gist-file .gist-data { + font-size: .8rem !important; + line-height: 1.4; +} +.gist code { + padding: 0; + color: inherit; + background-color: transparent; + border-radius: 0; +} + +/* Quotes */ +blockquote { + padding: .5rem 1rem; + margin: .8rem 0; + color: #7a7a7a; + border-left: .25rem solid #e5e5e5; +} +blockquote p:last-child { + margin-bottom: 0; +} +@media (min-width: 30em) { + blockquote { + padding-right: 5rem; + padding-left: 1.25rem; + } +} + +img { + display: block; + max-width: 100%; + margin: 0 0 1rem; + border-radius: 5px; +} + +/* Tables */ +table { + margin-bottom: 1rem; + width: 100%; + border: 1px solid #e5e5e5; + border-collapse: collapse; +} +td, +th { + padding: .25rem .5rem; + border: 1px solid #e5e5e5; +} +tbody tr:nth-child(odd) td, +tbody tr:nth-child(odd) th { + background-color: #f9f9f9; +} + + +/* + * Custom type + * + * Extend paragraphs with `.lead` for larger introductory text. + */ + +.lead { + font-size: 1.25rem; + font-weight: 300; +} + + +/* + * Messages + * + * Show alert messages to users. You may add it to single elements like a `

`, + * or to a parent if there are multiple elements to show. + */ + +.message { + margin-bottom: 1rem; + padding: 1rem; + color: #717171; + background-color: #f9f9f9; +} + + +/* + * Container + * + * Center the page content. + */ + +.container { + max-width: 38rem; + padding-left: 1rem; + padding-right: 1rem; + margin-left: auto; + margin-right: auto; +} + + +/* + * Masthead + * + * Super small header above the content for site name and short description. + */ + +.masthead { + padding-top: 1rem; + padding-bottom: 1rem; + margin-bottom: 3rem; +} +.masthead-title { + margin-top: 0; + margin-bottom: 0; + color: #505050; +} +.masthead-title a { + color: #505050; +} +.masthead-title small { + font-size: 75%; + font-weight: 400; + color: #c0c0c0; + letter-spacing: 0; +} + + +/* + * Posts and pages + * + * Each post is wrapped in `.post` and is used on default and post layouts. Each + * page is wrapped in `.page` and is only used on the page layout. + */ + +.page, +.post { + margin-bottom: 4em; +} + +/* Blog post or page title */ +.page-title, +.post-title, +.post-title a { + color: #303030; +} +.page-title, +.post-title { + margin-top: 0; +} + +/* Meta data line below post title */ +.post-date { + display: block; + margin-top: -.5rem; + margin-bottom: 1rem; + color: #9a9a9a; +} + +/* Related posts */ +.related { + padding-top: 2rem; + padding-bottom: 2rem; + border-top: 1px solid #eee; +} +.related-posts { + padding-left: 0; + list-style: none; +} +.related-posts h3 { + margin-top: 0; +} +.related-posts li small { + font-size: 75%; + color: #999; +} +.related-posts li a:hover { + color: #268bd2; + text-decoration: none; +} +.related-posts li a:hover small { + color: inherit; +} + + +/* + * Pagination + * + * Super lightweight (HTML-wise) blog pagination. `span`s are provide for when + * there are no more previous or next posts to show. + */ + +.pagination { + overflow: hidden; /* clearfix */ + margin-left: -1rem; + margin-right: -1rem; + font-family: "PT Sans", Helvetica, Arial, sans-serif; + color: #ccc; + text-align: center; +} + +/* Pagination items can be `span`s or `a`s */ +.pagination-item { + display: block; + padding: 1rem; + border: 1px solid #eee; +} +.pagination-item:first-child { + margin-bottom: -1px; +} + +/* Only provide a hover state for linked pagination items */ +a.pagination-item:hover { + background-color: #f5f5f5; +} + +@media (min-width: 30em) { + .pagination { + margin: 3rem 0; + } + .pagination-item { + float: left; + width: 50%; + } + .pagination-item:first-child { + margin-bottom: 0; + border-top-left-radius: 4px; + border-bottom-left-radius: 4px; + } + .pagination-item:last-child { + margin-left: -1px; + border-top-right-radius: 4px; + border-bottom-right-radius: 4px; + } +} diff --git a/public/css/syntax.css b/public/css/syntax.css new file mode 100644 index 00000000..15ad7977 --- /dev/null +++ b/public/css/syntax.css @@ -0,0 +1,65 @@ +.highlight .hll { background-color: #ffc; } +.highlight .c { color: #999; } /* Comment */ +.highlight .err { color: #a00; background-color: #faa } /* Error */ +.highlight .k { color: #069; } /* Keyword */ +.highlight .o { color: #555 } /* Operator */ +.highlight .cm { color: #09f; font-style: italic } /* Comment.Multiline */ +.highlight .cp { color: #099 } /* Comment.Preproc */ +.highlight .c1 { color: #999; } /* Comment.Single */ +.highlight .cs { color: #999; } /* Comment.Special */ +.highlight .gd { background-color: #fcc; border: 1px solid #c00 } /* Generic.Deleted */ +.highlight .ge { font-style: italic } /* Generic.Emph */ +.highlight .gr { color: #f00 } /* Generic.Error */ +.highlight .gh { color: #030; } /* Generic.Heading */ +.highlight .gi { background-color: #cfc; border: 1px solid #0c0 } /* Generic.Inserted */ +.highlight .go { color: #aaa } /* Generic.Output */ +.highlight .gp { color: #009; } /* Generic.Prompt */ +.highlight .gs { } /* Generic.Strong */ +.highlight .gu { color: #030; } /* Generic.Subheading */ +.highlight .gt { color: #9c6 } /* Generic.Traceback */ +.highlight .kc { color: #069; } /* Keyword.Constant */ +.highlight .kd { color: #069; } /* Keyword.Declaration */ +.highlight .kn { color: #069; } /* Keyword.Namespace */ +.highlight .kp { color: #069 } /* Keyword.Pseudo */ +.highlight .kr { color: #069; } /* Keyword.Reserved */ +.highlight .kt { color: #078; } /* Keyword.Type */ +.highlight .m { color: #f60 } /* Literal.Number */ +.highlight .s { color: #d44950 } /* Literal.String */ +.highlight .na { color: #4f9fcf } /* Name.Attribute */ +.highlight .nb { color: #366 } /* Name.Builtin */ +.highlight .nc { color: #0a8; } /* Name.Class */ +.highlight .no { color: #360 } /* Name.Constant */ +.highlight .nd { color: #99f } /* Name.Decorator */ +.highlight .ni { color: #999; } /* Name.Entity */ +.highlight .ne { color: #c00; } /* Name.Exception */ +.highlight .nf { color: #c0f } /* Name.Function */ +.highlight .nl { color: #99f } /* Name.Label */ +.highlight .nn { color: #0cf; } /* Name.Namespace */ +.highlight .nt { color: #2f6f9f; } /* Name.Tag */ +.highlight .nv { color: #033 } /* Name.Variable */ +.highlight .ow { color: #000; } /* Operator.Word */ +.highlight .w { color: #bbb } /* Text.Whitespace */ +.highlight .mf { color: #f60 } /* Literal.Number.Float */ +.highlight .mh { color: #f60 } /* Literal.Number.Hex */ +.highlight .mi { color: #f60 } /* Literal.Number.Integer */ +.highlight .mo { color: #f60 } /* Literal.Number.Oct */ +.highlight .sb { color: #c30 } /* Literal.String.Backtick */ +.highlight .sc { color: #c30 } /* Literal.String.Char */ +.highlight .sd { color: #c30; font-style: italic } /* Literal.String.Doc */ +.highlight .s2 { color: #c30 } /* Literal.String.Double */ +.highlight .se { color: #c30; } /* Literal.String.Escape */ +.highlight .sh { color: #c30 } /* Literal.String.Heredoc */ +.highlight .si { color: #a00 } /* Literal.String.Interpol */ +.highlight .sx { color: #c30 } /* Literal.String.Other */ +.highlight .sr { color: #3aa } /* Literal.String.Regex */ +.highlight .s1 { color: #c30 } /* Literal.String.Single */ +.highlight .ss { color: #fc3 } /* Literal.String.Symbol */ +.highlight .bp { color: #366 } /* Name.Builtin.Pseudo */ +.highlight .vc { color: #033 } /* Name.Variable.Class */ +.highlight .vg { color: #033 } /* Name.Variable.Global */ +.highlight .vi { color: #033 } /* Name.Variable.Instance */ +.highlight .il { color: #f60 } /* Literal.Number.Integer.Long */ + +.css .o, +.css .o + .nt, +.css .nt + .nt { color: #999; } diff --git a/public/favicon.ico b/public/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..2cd56085afa9abeff1bef566ed1fd9fcdeb4b03f GIT binary patch literal 340 zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1SJ1Ryj={WI14-?i-EKU7`vU!wgU;46*#5? zX$3HD|21bWka5`4#WBR=cyh?)3#kiK6Bey}xmb*ci#wvg^T&?e-~3)2)e4OX*pvD^ zPf0gHOib{&*2gC=H{UkT+puwymX_ur*5_yE?N0f4sg|Ap|G&@e9^4WipELW0KINT# z?eNZ5v#OS`UA)l$B#_%pSAtROgs1nf9lI}GVAAL3k4aS$)p_vffrgIek@am#+-G`t z6?uF^Q)fjyc=pUKfcG3%dw28UllQJ2zb+lQVeLk_nbI<1KKoexzHOVa(Y>cLqoHui zL({B-54Hn?;k<@f;Hq6NK<_A3g+!DD=ckpFCl;kLFjU+s_BrYA75d?fua7^km#@!C a76$z}tXJ0Ytn>w{X7F_Nb6Mw<&;$TXFM{*{ literal 0 HcmV?d00001 From 6172f51300c1a7c8139bd40f50250cf6a29cc0a5 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Fri, 8 Sep 2017 22:59:30 +0100 Subject: [PATCH 02/98] Modify structure. Add sample files to start structuring site. --- _config.yml | 20 ++- _includes/sidebar.html | 15 ++- _layouts/publication.html | 15 +++ _posts/2013-12-31-whats-jekyll.md | 12 -- _posts/2014-01-01-example-content.md | 122 ------------------ _posts/2014-01-02-introducing-lanyon.md | 38 ------ _publications/allamanis2013mining.markdown | 13 ++ _publications/allamanis2014learning.markdown | 33 +++++ _publications/allamanis2014mining.markdown | 13 ++ _publications/allamanis2015bimodal.markdown | 23 ++++ .../allamanis2015suggesting.markdown | 14 ++ .../allamanis2016convolutional.markdown | 27 ++++ _publications/allamanis2017mining.markdown | 13 ++ .../allamanis2017smartpaste.markdown | 25 ++++ 14 files changed, 192 insertions(+), 191 deletions(-) create mode 100644 _layouts/publication.html delete mode 100644 _posts/2013-12-31-whats-jekyll.md delete mode 100644 _posts/2014-01-01-example-content.md delete mode 100644 _posts/2014-01-02-introducing-lanyon.md create mode 100644 _publications/allamanis2013mining.markdown create mode 100644 _publications/allamanis2014learning.markdown create mode 100644 _publications/allamanis2014mining.markdown create mode 100644 _publications/allamanis2015bimodal.markdown create mode 100644 _publications/allamanis2015suggesting.markdown create mode 100644 _publications/allamanis2016convolutional.markdown create mode 100644 _publications/allamanis2017mining.markdown create mode 100644 _publications/allamanis2017smartpaste.markdown diff --git a/_config.yml b/_config.yml index 26efddf7..6eb9ab1f 100644 --- a/_config.yml +++ b/_config.yml @@ -4,17 +4,13 @@ permalink: pretty # Setup -title: Lanyon -tagline: 'A Jekyll theme' -description: 'A reserved Jekyll theme that places the utmost gravity on content with a hidden drawer. Made by @mdo.' -url: http://lanyon.getpoole.com +title: Machine Learning for Code +tagline: 'a literature review' +description: 'A survey of academic research on machine learning models for source code.' +url: http://todo.com baseurl: '' -# About/contact -author: - name: Mark Otto - url: https://twitter.com/mdo - email: markdotto@gmail.com - -# Custom vars -version: 1.0.0 +collections: + publications: + output: true + permalink: /:collection/:path/ diff --git a/_includes/sidebar.html b/_includes/sidebar.html index 520eebaf..c2136e9f 100644 --- a/_includes/sidebar.html +++ b/_includes/sidebar.html @@ -1,6 +1,6 @@ - +

- © {{ site.time | date: '%Y' }}. All rights reserved. + Powered by Jekyll and Lanyon.

diff --git a/_layouts/publication.html b/_layouts/publication.html new file mode 100644 index 00000000..b840111f --- /dev/null +++ b/_layouts/publication.html @@ -0,0 +1,15 @@ +--- +layout: default +--- + +
+

{{ page.title }}

+
{{ page.authors }}. {{ page.conference }} {{ page.year }}
+

[pdf] + {% for additional_link in page.additional_links %} + [{{ additional_link.name }}] + {% endfor %} +

+ +

{{ content }}

+
diff --git a/_posts/2013-12-31-whats-jekyll.md b/_posts/2013-12-31-whats-jekyll.md deleted file mode 100644 index 6bf2b50d..00000000 --- a/_posts/2013-12-31-whats-jekyll.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -layout: post -title: What's Jekyll? ---- - -[Jekyll](http://jekyllrb.com) is a static site generator, an open-source tool for creating simple yet powerful websites of all shapes and sizes. From [the project's readme](https://github.com/mojombo/jekyll/blob/master/README.markdown): - - > Jekyll is a simple, blog aware, static site generator. It takes a template directory [...] and spits out a complete, static website suitable for serving with Apache or your favorite web server. This is also the engine behind GitHub Pages, which you can use to host your project’s page or blog right here from GitHub. - -It's an immensely useful tool and one we encourage you to use here with Lanyon. - -Find out more by [visiting the project on GitHub](https://github.com/mojombo/jekyll). diff --git a/_posts/2014-01-01-example-content.md b/_posts/2014-01-01-example-content.md deleted file mode 100644 index 81e47487..00000000 --- a/_posts/2014-01-01-example-content.md +++ /dev/null @@ -1,122 +0,0 @@ ---- -layout: post -title: Example content ---- - - -
- Howdy! This is an example blog post that shows several types of HTML content supported in this theme. -
- -Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. *Aenean eu leo quam.* Pellentesque ornare sem lacinia quam venenatis vestibulum. Sed posuere consectetur est at lobortis. Cras mattis consectetur purus sit amet fermentum. - -> Curabitur blandit tempus porttitor. Nullam quis risus eget urna mollis ornare vel eu leo. Nullam id dolor id nibh ultricies vehicula ut id elit. - -Etiam porta **sem malesuada magna** mollis euismod. Cras mattis consectetur purus sit amet fermentum. Aenean lacinia bibendum nulla sed consectetur. - -## Inline HTML elements - -HTML defines a long list of available inline tags, a complete list of which can be found on the [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/HTML/Element). - -- **To bold text**, use ``. -- *To italicize text*, use ``. -- Abbreviations, like HTML should use ``, with an optional `title` attribute for the full phrase. -- Citations, like — Mark otto, should use ``. -- Deleted text should use `` and inserted text should use ``. -- Superscript text uses `` and subscript text uses ``. - -Most of these elements are styled by browsers with few modifications on our part. - -## Heading - -Vivamus sagittis lacus vel augue rutrum faucibus dolor auctor. Duis mollis, est non commodo luctus, nisi erat porttitor ligula, eget lacinia odio sem nec elit. Morbi leo risus, porta ac consectetur ac, vestibulum at eros. - -### Code - -Cum sociis natoque penatibus et magnis dis `code element` montes, nascetur ridiculus mus. - -{% highlight js %} -// Example can be run directly in your JavaScript console - -// Create a function that takes two arguments and returns the sum of those arguments -var adder = new Function("a", "b", "return a + b"); - -// Call the function -adder(2, 6); -// > 8 -{% endhighlight %} - -Aenean lacinia bibendum nulla sed consectetur. Etiam porta sem malesuada magna mollis euismod. Fusce dapibus, tellus ac cursus commodo, tortor mauris condimentum nibh, ut fermentum massa. - -### Lists - -Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Aenean lacinia bibendum nulla sed consectetur. Etiam porta sem malesuada magna mollis euismod. Fusce dapibus, tellus ac cursus commodo, tortor mauris condimentum nibh, ut fermentum massa justo sit amet risus. - -* Praesent commodo cursus magna, vel scelerisque nisl consectetur et. -* Donec id elit non mi porta gravida at eget metus. -* Nulla vitae elit libero, a pharetra augue. - -Donec ullamcorper nulla non metus auctor fringilla. Nulla vitae elit libero, a pharetra augue. - -1. Vestibulum id ligula porta felis euismod semper. -2. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. -3. Maecenas sed diam eget risus varius blandit sit amet non magna. - -Cras mattis consectetur purus sit amet fermentum. Sed posuere consectetur est at lobortis. - -
-
HyperText Markup Language (HTML)
-
The language used to describe and define the content of a Web page
- -
Cascading Style Sheets (CSS)
-
Used to describe the appearance of Web content
- -
JavaScript (JS)
-
The programming language used to build advanced Web sites and applications
-
- -Integer posuere erat a ante venenatis dapibus posuere velit aliquet. Morbi leo risus, porta ac consectetur ac, vestibulum at eros. Nullam quis risus eget urna mollis ornare vel eu leo. - -### Tables - -Aenean lacinia bibendum nulla sed consectetur. Lorem ipsum dolor sit amet, consectetur adipiscing elit. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
NameUpvotesDownvotes
Totals2123
Alice1011
Bob43
Charlie79
- -Nullam id dolor id nibh ultricies vehicula ut id elit. Sed posuere consectetur est at lobortis. Nullam quis risus eget urna mollis ornare vel eu leo. - ------ - -Want to see something else added? Open an issue. diff --git a/_posts/2014-01-02-introducing-lanyon.md b/_posts/2014-01-02-introducing-lanyon.md deleted file mode 100644 index 13e7ce48..00000000 --- a/_posts/2014-01-02-introducing-lanyon.md +++ /dev/null @@ -1,38 +0,0 @@ ---- -layout: post -title: Introducing Lanyon ---- - -Lanyon is an unassuming [Jekyll](http://jekyllrb.com) theme that places content first by tucking away navigation in a hidden drawer. It's based on [Poole](http://getpoole.com), the Jekyll butler. - -### Built on Poole - -Poole is the Jekyll Butler, serving as an upstanding and effective foundation for Jekyll themes by [@mdo](https://twitter.com/mdo). Poole, and every theme built on it (like Lanyon here) includes the following: - -* Complete Jekyll setup included (layouts, config, [404](/404), [RSS feed](/atom.xml), posts, and [example page](/about)) -* Mobile friendly design and development -* Easily scalable text and component sizing with `rem` units in the CSS -* Support for a wide gamut of HTML elements -* Related posts (time-based, because Jekyll) below each post -* Syntax highlighting, courtesy Pygments (the Python-based code snippet highlighter) - -### Lanyon features - -In addition to the features of Poole, Lanyon adds the following: - -* Toggleable sliding sidebar (built with only CSS) via **☰** link in top corner -* Sidebar includes support for textual modules and a dynamically generated navigation with active link support -* Two orientations for content and sidebar, default (left sidebar) and [reverse](https://github.com/poole/lanyon#reverse-layout) (right sidebar), available via `` classes -* [Eight optional color schemes](https://github.com/poole/lanyon#themes), available via `` classes - -[Head to the readme](https://github.com/poole/lanyon#readme) to learn more. - -### Browser support - -Lanyon is by preference a forward-thinking project. In addition to the latest versions of Chrome, Safari (mobile and desktop), and Firefox, it is only compatible with Internet Explorer 9 and above. - -### Download - -Lanyon is developed on and hosted with GitHub. Head to the GitHub repository for downloads, bug reports, and features requests. - -Thanks! diff --git a/_publications/allamanis2013mining.markdown b/_publications/allamanis2013mining.markdown new file mode 100644 index 00000000..79051ded --- /dev/null +++ b/_publications/allamanis2013mining.markdown @@ -0,0 +1,13 @@ +--- +layout: publication +title: "Mining Source Code Repositories at Massive Scale Using Language Modeling " +authors: M. Allamanis, C. Sutton +conference: MSR +year: 2013 +featured: false +bibkey: allamanis2013mining +additional_links: + - {name: "data", url: "http://groups.inf.ed.ac.uk/cup/javaGithub/"} + - {name: "data@ Edinburgh DataShare", url: "http://datashare.is.ed.ac.uk/handle/10283/2334"} +--- +The tens of thousands of high-quality open source software projects on the Internet raise the exciting possibility of studying software development by finding patterns across truly large source code repositories. This could enable new tools for developing code, encouraging reuse, and navigating large projects. In this paper, we build the first giga-token probabilistic language model of source code, based on 352 million lines of Java. This is 100 times the scale of the pioneering work by Hindle et al. The giga-token model is significantly better at the code suggestion task than previous models. More broadly, our approach provides a new “lens” for analyzing software projects, enabling new complexity metrics based on statistical analysis of large corpora. We call these metrics data-driven complexity metrics. We propose new metrics that measure the complexity of a code module and the topical centrality of a module to a software project. In particular, it is possible to distinguish reusable utility classes from classes that are part of a program’s core logic based solely on general information theoretic criteria. diff --git a/_publications/allamanis2014learning.markdown b/_publications/allamanis2014learning.markdown new file mode 100644 index 00000000..08aa6a01 --- /dev/null +++ b/_publications/allamanis2014learning.markdown @@ -0,0 +1,33 @@ +--- +layout: publication +title: Learning Natural Coding Conventions +authors: M. Allamanis, E. T. Barr, C. Bird, C. Sutton +conference: FSE +year: 2014 +featured: false +bibkey: allamanis2014learning +additional_links: + - {name: "ArXiV", url: "http://arxiv.org/abs/1402.4182"} + - {name: "website", url: "http://groups.inf.ed.ac.uk/naturalize/"} + - {name: "code", url: "https://github.com/mast-group/naturalize"} +--- +Every programmer has a characteristic style, ranging from preferences +about identifier naming to preferences about object relationships and +design patterns. Coding conventions define a consistent syntactic style, +fostering readability and hence maintainability. When collaborating, +programmers strive to obey a project’s coding conventions. However, +one third of reviews of changes contain feedback about coding conventions, +indicating that programmers do not always follow them and that project +members care deeply about adherence. Unfortunately, programmers are +often unaware of coding conventions because inferring them requires a +global view, one that aggregates the many local decisions programmers +make and identifies emergent consensus on style. We present Naturalize, +a framework that learns the style of a codebase, and suggests revisions +to improve stylistic consistency. Naturalize builds on recent work in +applying statistical natural language processing to source code. We +apply Naturalize to suggest natural identifier names and formatting +conventions. We present four tools focused on ensuring natural code +during development and release management, including code review. +Naturalize achieves 94% accuracy in its top suggestions for identifier +names. We used Naturalize to generate 18 patches for 5 open source +projects: 14 were accepted. diff --git a/_publications/allamanis2014mining.markdown b/_publications/allamanis2014mining.markdown new file mode 100644 index 00000000..ae8db47a --- /dev/null +++ b/_publications/allamanis2014mining.markdown @@ -0,0 +1,13 @@ +--- +layout: publication +title: "Mining Idioms from Source Code" +authors: M. Allamanis, C. Sutton +conference: FSE +year: 2014 +featured: false +bibkey: allamanis2014mining +additional_links: + - {name: "ArXiV", url: "http://arxiv.org/abs/1404.0417"} + - {name: "data", url: "http://groups.inf.ed.ac.uk/cup/idioms/haggisClassUsersDataset.zip"} +--- +We present the first method for automatically mining code idioms from a corpus of previously written, idiomatic software projects. We take the view that a code idiom is a syntactic fragment that recurs across projects and has a single semantic purpose. Idioms may have metavariables, such as the body of a for loop. Modern IDEs commonly provide facilities for manually defining idioms and inserting them on demand, but this does not help programmers to write idiomatic code in languages or using libraries with which they are unfamiliar. We present Haggis, a system for mining code idioms that builds on recent advanced techniques from statistical natural language processing, namely, nonparametric Bayesian probabilistic tree substitution grammars. We apply Haggis to several of the most popular open source projects from GitHub. We present a wide range of evidence that the resulting idioms are semantically meaningful, demonstrating that they do indeed recur across software projects and that they occur more frequently in illustrative code examples collected from a Q&A site. Manual examination of the most common idioms indicate that they describe important program concepts, including object creation, exception handling, and resource management. diff --git a/_publications/allamanis2015bimodal.markdown b/_publications/allamanis2015bimodal.markdown new file mode 100644 index 00000000..3c7c1928 --- /dev/null +++ b/_publications/allamanis2015bimodal.markdown @@ -0,0 +1,23 @@ +--- +layout: publication +title: A Bimodal Modelling of Source Code and Natural Language +authors: M. Allamanis, D. Tarlow, A. D. Gordon, Y. Wei +conference: ICML +year: 2015 +featured: false +bibkey: allamanis2015bimodal +additional_links: + - {name: "Supplementary Material", url: "/publicationfiles/allamanis2015bimodal/supplementary.pdf"} + - {name: "Presentation Video", url: "http://videolectures.net/icml2015_allamanis_natural_language/"} +--- +We consider the problem of building probabilistic models that jointly +model short natural language utterances and source code snippets. The +aim is to bring together recent work on statistical modelling of source +code and work on bimodal models of images and natural language. The +resulting models are useful for a variety of tasks that involve natural +language and source code. We demonstrate their performance on two +retrieval tasks: retrieving source code snippets given a natural language +query, and retrieving natural language descriptions given a source code +query (i.e., source code captioning). Experiments show there to be +promise in this direction, and that modelling the structure of source +code improves performance. diff --git a/_publications/allamanis2015suggesting.markdown b/_publications/allamanis2015suggesting.markdown new file mode 100644 index 00000000..568b355a --- /dev/null +++ b/_publications/allamanis2015suggesting.markdown @@ -0,0 +1,14 @@ +--- +layout: publication +title: Suggesting Accurate Method and Class Names +authors: M. Allamanis, E. T. Barr, C. Bird, C. Sutton +conference: FSE +year: 2015 +featured: false +bibkey: allamanis2015suggesting +additional_links: + - {name: "website", url: "http://groups.inf.ed.ac.uk/cup/naturalize"} +--- +Descriptive names are a vital part of readable, and hence maintainable, code. Recent progress on automatically suggesting names for local variables tantalizes with the prospect of replicating that success with method and class names. However, suggesting names for methods and classes is much more difficult. This is because good method and class names need to be functionally descriptive, but suggesting such names requires that the model goes beyond local context. We introduce a neural probabilistic language model for source code that is specifically designed for the method naming problem. Our model learns which names are semantically similar by assigning them to locations, called embeddings, in a high-dimensional continuous space, in such a way that names with similar embeddings tend to be used in similar contexts. These embeddings seem to contain semantic information about tokens, even though they are learned only from statistical co-occurrences of tokens. Furthermore, we introduce a variant of our model +that is, to our knowledge, the first that can propose neologisms, names that have not appeared in the training corpus. We obtain state of the art results on the method, class, and even the simpler variable naming tasks. More broadly, the continuous embeddings that are learned by our model have the potential for wide application within software engineering. + diff --git a/_publications/allamanis2016convolutional.markdown b/_publications/allamanis2016convolutional.markdown new file mode 100644 index 00000000..0425b8cf --- /dev/null +++ b/_publications/allamanis2016convolutional.markdown @@ -0,0 +1,27 @@ +--- +layout: publication +title: A Convolutional Attention Network for Extreme Summarization of Source Code +authors: M. Allamanis, H. Peng, C. Sutton +conference: ICML +year: 2016 +featured: true +bibkey: allamanis2016convolutional +additional_links: + - {name: "website", url: "http://groups.inf.ed.ac.uk/cup/codeattention/"} + - {name: "code", url: "https://github.com/mast-group/convolutional-attention"} + - {name: "proceedings", url: "http://jmlr.org/proceedings/papers/v48/allamanis16.pdf"} + - {name: "presentation video", url: "http://techtalks.tv/talks/a-convolutional-attention-network-for-extreme-summarization-of-source-code/62461/"} + - {name: "GitXiV", url: "http://gitxiv.com/posts/A6HFFyK7CmNLaSjG7/a-convolutional-attention-network-for-extreme-summarization"} +--- +Attention mechanisms in neural networks have proved useful for problems in which +the input and output do not have fixed dimension. Often there exist features that +are locally translation invariant and would be valuable for directing the model’s attention, +but previous attentional architectures are not constructed to learn such features specifically. +We introduce an attentional neural network that employs convolution on the input tokens to detect +local time-invariant and long-range topical attention features in a context-dependent way. We +apply this architecture to the problem of extreme summarization of source code snippets into short, +descriptive function name-like summaries. Using those features, the model sequentially generates a +summary by marginalizing over two attention mechanisms: one that predicts the next summary token based +n the attention weights of the input tokens and another that is able to copy a code token as-is directly +into the summary. We demonstrate our convolutional attention neural network’s performance on 10 popular Java +projects showing that it achieves better performance compared to previous attentional mechanisms. diff --git a/_publications/allamanis2017mining.markdown b/_publications/allamanis2017mining.markdown new file mode 100644 index 00000000..ac52e2a6 --- /dev/null +++ b/_publications/allamanis2017mining.markdown @@ -0,0 +1,13 @@ +--- +layout: publication +title: Mining Semantic Loop Idioms from Big Code +authors: M. Allamanis, E. T. Barr, C. Bird, M. Marron, C. Sutton +conference: "" +year: 2017 +featured: false +bibkey: allamanis2017mining +additional_links: + - {name: "MSR Technical Report", url: "https://www.microsoft.com/en-us/research/publication/mining-semantic-loop-idioms-big-code/"} + - {name: "website", url: "http://groups.inf.ed.ac.uk/cup/semantic-idioms/"} +--- +During maintenance, developers spend a lot of time transforming existing code: refactoring, optimizing, and adding checks to make it more robust. Much of this work is the drudgery of identifying and replacing specific patterns, yet it resists automation, because of meaningful patterns are hard to automatically find. We present a technique for mining loop idioms, surprisingly probable semantic patterns that occur in loops, from big code to find meaningful patterns. First, we show that automatically identifiable patterns exist, in great numbers, with a large scale empirical study of loop over 25 MLOC. We find that loops in this corpus are simple and predictable: 90% of them have fewer than 15LOC and 90% have no nesting and very simple control structure. Encouraged by this result, we coil loops to abstract away syntactic diversity to define information rich loop idioms. We show that only 50 loop idioms cover 50% of the concrete loops. We show how loop idioms can help a tool developers identify and prioritize refactorings. We also show how our framework opens the door to data-driven tool and language design discovering opportunities to introduce new API calls and language constructs: loop idioms show that LINQ would benefit from an Enumerate operator, a result confirmed by the fact that precisely this feature is one of the most requested features on StackOverflow with 197 votes and 95k views. diff --git a/_publications/allamanis2017smartpaste.markdown b/_publications/allamanis2017smartpaste.markdown new file mode 100644 index 00000000..e6e871b9 --- /dev/null +++ b/_publications/allamanis2017smartpaste.markdown @@ -0,0 +1,25 @@ +--- +layout: publication +title: "SmartPaste: Learning to Adapt Source Code" +authors: M. Allamanis, M. Brockscmidt +conference: "" +year: 2017 +featured: true +bibkey: allamanis2017smartpaste +additional_links: + - {name: "ArXiV", url: "https://arxiv.org/abs/1705.07867"} +--- +Deep Neural Networks have been shown to succeed at a range of natural +language tasks such as machine translation and text summarization. +While tasks on source code (ie, formal languages) have been considered +recently, most work in this area does not attempt to capitalize on the +unique opportunities offered by its known syntax and structure. In this +work, we introduce SmartPaste, a first task that requires to use such +information. The task is a variant of the program repair problem that +requires to adapt a given (pasted) snippet of code to surrounding, +existing source code. As first solutions, we design a set of deep +neural models that learn to represent the context of each variable +location and variable usage in a data flow-sensitive way. Our +evaluation suggests that our models can learn to solve the SmartPaste +task in many cases, achieving 58.6% accuracy, while learning meaningful +representation of variable usages. From 6bd43733eeb698b46704142c174c83d1813e823e Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sat, 9 Sep 2017 00:09:46 +0100 Subject: [PATCH 03/98] Basic structure. --- _config.yml | 5 ---- _includes/sidebar.html | 10 +++---- _publications/allamanis2013mining.markdown | 1 - _publications/allamanis2014learning.markdown | 1 - _publications/allamanis2014mining.markdown | 1 - _publications/allamanis2015bimodal.markdown | 1 - .../allamanis2015suggesting.markdown | 1 - .../allamanis2016convolutional.markdown | 1 - _publications/allamanis2017mining.markdown | 1 - .../allamanis2017smartpaste.markdown | 1 - about.md | 30 ------------------- contributing.markdown | 30 +++++++++++++++++++ index.md | 19 ++++++++++++ index.html => papers.html | 0 14 files changed, 53 insertions(+), 49 deletions(-) delete mode 100644 about.md create mode 100644 contributing.markdown create mode 100644 index.md rename index.html => papers.html (100%) diff --git a/_config.yml b/_config.yml index 6eb9ab1f..a79b978e 100644 --- a/_config.yml +++ b/_config.yml @@ -1,8 +1,3 @@ -# Permalinks -# -# Use of `relative_permalinks` ensures post links from the index work properly. -permalink: pretty - # Setup title: Machine Learning for Code tagline: 'a literature review' diff --git a/_includes/sidebar.html b/_includes/sidebar.html index c2136e9f..6e22812d 100644 --- a/_includes/sidebar.html +++ b/_includes/sidebar.html @@ -9,13 +9,12 @@
diff --git a/_publications/allamanis2013mining.markdown b/_publications/allamanis2013mining.markdown index 79051ded..1ab2a042 100644 --- a/_publications/allamanis2013mining.markdown +++ b/_publications/allamanis2013mining.markdown @@ -4,7 +4,6 @@ title: "Mining Source Code Repositories at Massive Scale Using Language Modeling authors: M. Allamanis, C. Sutton conference: MSR year: 2013 -featured: false bibkey: allamanis2013mining additional_links: - {name: "data", url: "http://groups.inf.ed.ac.uk/cup/javaGithub/"} diff --git a/_publications/allamanis2014learning.markdown b/_publications/allamanis2014learning.markdown index 08aa6a01..e6e540f7 100644 --- a/_publications/allamanis2014learning.markdown +++ b/_publications/allamanis2014learning.markdown @@ -4,7 +4,6 @@ title: Learning Natural Coding Conventions authors: M. Allamanis, E. T. Barr, C. Bird, C. Sutton conference: FSE year: 2014 -featured: false bibkey: allamanis2014learning additional_links: - {name: "ArXiV", url: "http://arxiv.org/abs/1402.4182"} diff --git a/_publications/allamanis2014mining.markdown b/_publications/allamanis2014mining.markdown index ae8db47a..45f195ac 100644 --- a/_publications/allamanis2014mining.markdown +++ b/_publications/allamanis2014mining.markdown @@ -4,7 +4,6 @@ title: "Mining Idioms from Source Code" authors: M. Allamanis, C. Sutton conference: FSE year: 2014 -featured: false bibkey: allamanis2014mining additional_links: - {name: "ArXiV", url: "http://arxiv.org/abs/1404.0417"} diff --git a/_publications/allamanis2015bimodal.markdown b/_publications/allamanis2015bimodal.markdown index 3c7c1928..7d94f6fd 100644 --- a/_publications/allamanis2015bimodal.markdown +++ b/_publications/allamanis2015bimodal.markdown @@ -4,7 +4,6 @@ title: A Bimodal Modelling of Source Code and Natural Language authors: M. Allamanis, D. Tarlow, A. D. Gordon, Y. Wei conference: ICML year: 2015 -featured: false bibkey: allamanis2015bimodal additional_links: - {name: "Supplementary Material", url: "/publicationfiles/allamanis2015bimodal/supplementary.pdf"} diff --git a/_publications/allamanis2015suggesting.markdown b/_publications/allamanis2015suggesting.markdown index 568b355a..dd132baa 100644 --- a/_publications/allamanis2015suggesting.markdown +++ b/_publications/allamanis2015suggesting.markdown @@ -4,7 +4,6 @@ title: Suggesting Accurate Method and Class Names authors: M. Allamanis, E. T. Barr, C. Bird, C. Sutton conference: FSE year: 2015 -featured: false bibkey: allamanis2015suggesting additional_links: - {name: "website", url: "http://groups.inf.ed.ac.uk/cup/naturalize"} diff --git a/_publications/allamanis2016convolutional.markdown b/_publications/allamanis2016convolutional.markdown index 0425b8cf..35d04c4e 100644 --- a/_publications/allamanis2016convolutional.markdown +++ b/_publications/allamanis2016convolutional.markdown @@ -4,7 +4,6 @@ title: A Convolutional Attention Network for Extreme Summarization of Source Cod authors: M. Allamanis, H. Peng, C. Sutton conference: ICML year: 2016 -featured: true bibkey: allamanis2016convolutional additional_links: - {name: "website", url: "http://groups.inf.ed.ac.uk/cup/codeattention/"} diff --git a/_publications/allamanis2017mining.markdown b/_publications/allamanis2017mining.markdown index ac52e2a6..4259efeb 100644 --- a/_publications/allamanis2017mining.markdown +++ b/_publications/allamanis2017mining.markdown @@ -4,7 +4,6 @@ title: Mining Semantic Loop Idioms from Big Code authors: M. Allamanis, E. T. Barr, C. Bird, M. Marron, C. Sutton conference: "" year: 2017 -featured: false bibkey: allamanis2017mining additional_links: - {name: "MSR Technical Report", url: "https://www.microsoft.com/en-us/research/publication/mining-semantic-loop-idioms-big-code/"} diff --git a/_publications/allamanis2017smartpaste.markdown b/_publications/allamanis2017smartpaste.markdown index e6e871b9..00b16da2 100644 --- a/_publications/allamanis2017smartpaste.markdown +++ b/_publications/allamanis2017smartpaste.markdown @@ -4,7 +4,6 @@ title: "SmartPaste: Learning to Adapt Source Code" authors: M. Allamanis, M. Brockscmidt conference: "" year: 2017 -featured: true bibkey: allamanis2017smartpaste additional_links: - {name: "ArXiV", url: "https://arxiv.org/abs/1705.07867"} diff --git a/about.md b/about.md deleted file mode 100644 index 9b2605bb..00000000 --- a/about.md +++ /dev/null @@ -1,30 +0,0 @@ ---- -layout: page -title: About ---- - -

- Hey there! This page is included as an example. Feel free to customize it for your own use upon downloading. Carry on! -

- -In the novel, *The Strange Case of Dr. Jeykll and Mr. Hyde*, Mr. Poole is Dr. Jekyll's virtuous and loyal butler. Similarly, Poole is an upstanding and effective butler that helps you build Jekyll themes. It's made by [@mdo](https://twitter.com/mdo). - -There are currently two themes built on Poole: - -* [Hyde](http://hyde.getpoole.com) -* [Lanyon](http://lanyon.getpoole.com) - -Learn more and contribute on [GitHub](https://github.com/poole). - -## Setup - -Some fun facts about the setup of this project include: - -* Built for [Jekyll](http://jekyllrb.com) -* Developed on GitHub and hosted for free on [GitHub Pages](https://pages.github.com) -* Coded with [Sublime Text 2](http://sublimetext.com), an amazing code editor -* Designed and developed while listening to music like [Blood Bros Trilogy](https://soundcloud.com/maddecent/sets/blood-bros-series) - -Have questions or suggestions? Feel free to [open an issue on GitHub](https://github.com/poole/issues/new) or [ask me on Twitter](https://twitter.com/mdo). - -Thanks for reading! diff --git a/contributing.markdown b/contributing.markdown new file mode 100644 index 00000000..3245937c --- /dev/null +++ b/contributing.markdown @@ -0,0 +1,30 @@ +--- +layout: page +title: Contributing +--- + +Contributions of new or missing publications are very welcome. Alternative categorization/taxonomies can also be added to the website. To contribute, please open a pull request [here](https://github.com/ml4code/ml4code.github.io), but first please read the instructions below. + +## Adding a publication +To add a publication (new or missing), create a file in the `_publications` folder. The name of the file should follow the structure `lastnameYEARfirstword.markdown` where `lastname` is the last name of the first author and `firstword` is the first non-punctuation word of the work's title. Within each file, follow the structure shown in the other files. +
+---
+layout: publication
+title: The title of the Publication
+authors: F. M. LastName, F. M. LastName, ...
+conference: AbbreviatedNameOfConference
+year: YEAR
+bibkey: lastnameYEARfirstword
+additional_links:
+   - {name: "ArXiV", url: "http://arxiv.org/abs/XXXX.YYYY"}
+   - {name: "website", url: "http://paperwebsite.com/"}
+   - {name: "code", url: "https://github.com/path-to/code"}
+---
+text-of-abstract
+
+ +The `additional_links` are optional and arbitrary and they will appear on the page refering to this work. Feel free to add as many additional links as needed. + +## Adding a new categorization +No single taxonomy or categorization can fit everyone. It is easy to contribute a new categorization to be shown in this website. TODO TODO + diff --git a/index.md b/index.md new file mode 100644 index 00000000..c066d593 --- /dev/null +++ b/index.md @@ -0,0 +1,19 @@ +--- +layout: page +title: About the Survey +--- + +Intro about ml 4 code + +## The survey +Link to paper + +Please cite as +
+TODO
+
+ +## Contributing + +We understand that this is an area that is evolving fast and a static review cannot reflect the continuous evolution of the area. But a website can! We hope to make this site a living document. To contribute, open a pull request in GitHub. Please, read the instructions [here](contributing.html). + diff --git a/index.html b/papers.html similarity index 100% rename from index.html rename to papers.html From 03bf8e2c0fdac8bbba3844ceebbb83e4c6829acf Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sat, 9 Sep 2017 23:41:54 +0100 Subject: [PATCH 04/98] Added all papers section and started creating taxonomy. --- _data/allamanistaxonomy.yml | 63 +++++++++++++++++++++++++++++++++++++ _includes/sidebar.html | 23 +++++--------- base-taxonomy/index.md | 26 +++++++++++++++ contributing.markdown | 2 +- index.md | 2 ++ papers.html | 43 +++++++------------------ 6 files changed, 110 insertions(+), 49 deletions(-) create mode 100644 _data/allamanistaxonomy.yml create mode 100644 base-taxonomy/index.md diff --git a/_data/allamanistaxonomy.yml b/_data/allamanistaxonomy.yml new file mode 100644 index 00000000..d1bb914e --- /dev/null +++ b/_data/allamanistaxonomy.yml @@ -0,0 +1,63 @@ +--- + bibkey: allamanis2013mining + categories: [generative] + type: lm + representation: Tokens + model: n-gram LM + +--- + bibkey: allamanis2014learning + categories: [generative] + type: lm + representation: Tokens + model: n-gram LM + application: Coding Conventions + +--- + bibkey: allamanis2014mining + categories: [generative, pattern] + type: lm + representation: AST + model: pTSG + application: Idiom Mining + +--- + bibkey: allamanis2015bimodal + categories: [generative] + type: multimodal + representation: AST + model: Neural LM + application: Code Search/Synthesis + +--- + bibkey: allamanis2015suggesting + categories: [representational] + representation: distributed + application: Naming Conventions + input_rep: Token Context + target_rep: Identifier Name + +--- + bibkey: allamanis2016convolutional + categories: [representational] + representation: Tokens + application: Method Naming Conventions + input_rep: Token + target_rep: Method Name + +--- + bibkey: allamanis2017mining + categories: [generative, pattern] + type: lm + representation: AST + model: pTSG + application: Idiom Mining + +--- + bibkey: allamanis2017smartpaste + categories: [representational] + representation: Distributed + application: Code Contextualization and Bug Finding + input_rep: Data Flow + target_rep: Variable Allocation + diff --git a/_includes/sidebar.html b/_includes/sidebar.html index 6e22812d..e29ed8b9 100644 --- a/_includes/sidebar.html +++ b/_includes/sidebar.html @@ -11,22 +11,13 @@
diff --git a/base-taxonomy/index.md b/base-taxonomy/index.md new file mode 100644 index 00000000..c9732310 --- /dev/null +++ b/base-taxonomy/index.md @@ -0,0 +1,26 @@ +--- +layout: page +title: Taxonomy +--- +A probabilistic model of source code is a probability distribution +over code artifacts. To group these family of models +in terms of shared design choices, +we separate these models into three categories, +based on the form of the equation of the modeled probability +distribution and their inputs and outputs. Some models fall into multiple categories +because decompositions of their equations fall into different categories. + + + * **Code-generating Models** generate code by + stochastically modeling the generation of smaller and simpler parts of code, _e.g._ + tokens or AST nodes. + + * **Representational Models of Code** take an abstract representation of + code as input. Example representations include token contexts or data flow. + The resulting model yields a conditional probability distribution over code + element properties, like the types of variables, and can predict them. + + * **Pattern Mining Models** infer, without supervision, a likely latent + structure within code. These models are an instantiation of clustering + in the code domain; they can find reusable and human-interpretable patterns. + diff --git a/contributing.markdown b/contributing.markdown index 3245937c..bf999229 100644 --- a/contributing.markdown +++ b/contributing.markdown @@ -6,7 +6,7 @@ title: Contributing Contributions of new or missing publications are very welcome. Alternative categorization/taxonomies can also be added to the website. To contribute, please open a pull request [here](https://github.com/ml4code/ml4code.github.io), but first please read the instructions below. ## Adding a publication -To add a publication (new or missing), create a file in the `_publications` folder. The name of the file should follow the structure `lastnameYEARfirstword.markdown` where `lastname` is the last name of the first author and `firstword` is the first non-punctuation word of the work's title. Within each file, follow the structure shown in the other files. +To add a publication (new or missing), create a file in the `_publications` folder. The name of the file should follow the structure `lastnameYEARfirstword.markdown` where `lastname` is the last name of the first author and `firstword` is the first non-punctuation word of the work's title. Within each file, follow the structure shown in the other files. Once the file is added, the work will appear in the "All Papers" section. 
 ---
 layout: publication
diff --git a/index.md b/index.md
index c066d593..6062016c 100644
--- a/index.md
+++ b/index.md
@@ -13,6 +13,8 @@ Please cite as
 TODO
+Regarding this review or website, please contact [Miltos Allamanis](https://miltos.allamanis.com). + ## Contributing We understand that this is an area that is evolving fast and a static review cannot reflect the continuous evolution of the area. But a website can! We hope to make this site a living document. To contribute, open a pull request in GitHub. Please, read the instructions [here](contributing.html). diff --git a/papers.html b/papers.html index e4c52988..9d84a81d 100644 --- a/papers.html +++ b/papers.html @@ -3,36 +3,15 @@ title: Home --- -
- {% for post in paginator.posts %} -
-

- - {{ post.title }} - -

- - {{ post.date | date_to_string }} - - {{ post.content }} -
- {% endfor %} -
- - +{% assign publicationsByYear = site.publications | group_by:"year" %} +{% for year in publicationsByYear reversed %} +

{{ year.name }}

+
    + {% for publication in year.items %} +
  • + {{publication.title}}. {{ publication.authors }}. {{publication.conference}}. +
    • + {% endfor %} +
+{% endfor %} From f867e81fd0d8d5b51c864accc01239d2efe358e0 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sun, 10 Sep 2017 04:54:14 +0100 Subject: [PATCH 05/98] chore: add some favico --- _includes/head.html | 6 +++--- public/apple-touch-icon-precomposed.png | Bin 831 -> 0 bytes public/favicon.ico | Bin 340 -> 0 bytes public/favicon.svg | 4 ++++ 4 files changed, 7 insertions(+), 3 deletions(-) delete mode 100644 public/apple-touch-icon-precomposed.png delete mode 100644 public/favicon.ico create mode 100644 public/favicon.svg diff --git a/_includes/head.html b/_includes/head.html index 1948f301..f5af2512 100644 --- a/_includes/head.html +++ b/_includes/head.html @@ -10,7 +10,7 @@ {% if page.title == "Home" %} {{ site.title }} · {{ site.tagline }} {% else %} - {{ page.title }} · {{ site.title }} + {{ site.title }} · {{ page.title }} {% endif %} @@ -21,8 +21,8 @@ - - + + diff --git a/public/apple-touch-icon-precomposed.png b/public/apple-touch-icon-precomposed.png deleted file mode 100644 index 6cb41a8e552c6150fe56b3e7dec516fb20093793..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 831 zcmeAS@N?(olHy`uVBq!ia0vp^GeDSw2}n*~u)PdONtU=qlmzFem6RtIr7}3C&;z9@5zNS2R@25`Asfh;AKnX+Na7u<97pKfq@h3WR^mA`88 z?UHTy&$mDSZ(}bLt#tR^R^N;HyMq~m6j*~49J!V_aH)7Sih$4rCd~;tYEVtKwv^Ph03*mqU=WF?`)+l_csf7$lbVq?eg8ZCriHZf0dPmchuUsuf3nV1IIRN=fxMh6GLk=k zZMu23Znx5OYaSz`-ky294+9(jy#Dy{%!v)95ooLJGzi`&*fMKaA}@awOyN0x{Ma$D%Ixgb7d1FHF+EN3U!RoRfdo7Gf15=v@yE0Bi`VYm+j?lDea(>@8y@Wa|LNPOtgI}ipL>obxb$mz>>h)i?~)gFJvr>RGNdW-kATMnuF%es z>gk&wbfKpkRv}<|f(1S}JwXE>EPm?sYzAfquV*D64qq{42j&O{Pgg&ebxsLQ0K4yS AE&u=k diff --git a/public/favicon.ico b/public/favicon.ico deleted file mode 100644 index 2cd56085afa9abeff1bef566ed1fd9fcdeb4b03f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 340 zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1SJ1Ryj={WI14-?i-EKU7`vU!wgU;46*#5? zX$3HD|21bWka5`4#WBR=cyh?)3#kiK6Bey}xmb*ci#wvg^T&?e-~3)2)e4OX*pvD^ zPf0gHOib{&*2gC=H{UkT+puwymX_ur*5_yE?N0f4sg|Ap|G&@e9^4WipELW0KINT# z?eNZ5v#OS`UA)l$B#_%pSAtROgs1nf9lI}GVAAL3k4aS$)p_vffrgIek@am#+-G`t z6?uF^Q)fjyc=pUKfcG3%dw28UllQJ2zb+lQVeLk_nbI<1KKoexzHOVa(Y>cLqoHui zL({B-54Hn?;k<@f;Hq6NK<_A3g+!DD=ckpFCl;kLFjU+s_BrYA75d?fua7^km#@!C a76$z}tXJ0Ytn>w{X7F_Nb6Mw<&;$TXFM{*{ diff --git a/public/favicon.svg b/public/favicon.svg new file mode 100644 index 00000000..d081df94 --- /dev/null +++ b/public/favicon.svg @@ -0,0 +1,4 @@ + + + + From 8e288e9fa7c31c3809aefd7333971ce8e6de0ea2 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sun, 10 Sep 2017 22:38:47 +0100 Subject: [PATCH 06/98] Added placeholders for taxonomy. --- base-taxonomy/generative.md | 4 ++++ base-taxonomy/index.md | 7 ++++--- base-taxonomy/pattern.md | 4 ++++ base-taxonomy/representational.md | 4 ++++ contributing.markdown | 5 +++++ 5 files changed, 21 insertions(+), 3 deletions(-) create mode 100644 base-taxonomy/generative.md create mode 100644 base-taxonomy/pattern.md create mode 100644 base-taxonomy/representational.md diff --git a/base-taxonomy/generative.md b/base-taxonomy/generative.md new file mode 100644 index 00000000..fc74651b --- /dev/null +++ b/base-taxonomy/generative.md @@ -0,0 +1,4 @@ +--- +layout: page +title: Code-Generating Models +--- diff --git a/base-taxonomy/index.md b/base-taxonomy/index.md index c9732310..7bf026e9 100644 --- a/base-taxonomy/index.md +++ b/base-taxonomy/index.md @@ -11,16 +11,17 @@ distribution and their inputs and outputs. Some models fall into multiple catego because decompositions of their equations fall into different categories. - * **Code-generating Models** generate code by + * [**Code-generating Models**](generative.html) generate code by stochastically modeling the generation of smaller and simpler parts of code, _e.g._ tokens or AST nodes. - * **Representational Models of Code** take an abstract representation of + * [**Representational Models of Code**](representational.html) take an abstract + representation of code as input. Example representations include token contexts or data flow. The resulting model yields a conditional probability distribution over code element properties, like the types of variables, and can predict them. - * **Pattern Mining Models** infer, without supervision, a likely latent + * [**Pattern Mining Models**](pattern.html) infer, without supervision, a likely latent structure within code. These models are an instantiation of clustering in the code domain; they can find reusable and human-interpretable patterns. diff --git a/base-taxonomy/pattern.md b/base-taxonomy/pattern.md new file mode 100644 index 00000000..7bdcf547 --- /dev/null +++ b/base-taxonomy/pattern.md @@ -0,0 +1,4 @@ +--- +layout: page +title: Pattern Mining Models +--- diff --git a/base-taxonomy/representational.md b/base-taxonomy/representational.md new file mode 100644 index 00000000..17afc228 --- /dev/null +++ b/base-taxonomy/representational.md @@ -0,0 +1,4 @@ +--- +layout: page +title: Representational Models +--- diff --git a/contributing.markdown b/contributing.markdown index bf999229..f55cd9d8 100644 --- a/contributing.markdown +++ b/contributing.markdown @@ -28,3 +28,8 @@ The `additional_links` are optional and arbitrary and they will appear on the pa ## Adding a new categorization No single taxonomy or categorization can fit everyone. It is easy to contribute a new categorization to be shown in this website. TODO TODO +Add a data file describing your hierarchy. This can be a JSON, YAML or CSV file as described [here](https://jekyllrb.com/docs/datafiles/). + +## Reusing the website structure +In principle, the structure of this website can be used for other literature reviews. Feel free to clone it! + From aff390fdf43cf678a88c8f450ca90e69660a0a06 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sun, 10 Sep 2017 22:52:25 +0100 Subject: [PATCH 07/98] Moved to hyde theme --- 404.html | 2 +- _includes/head.html | 9 +- _includes/sidebar.html | 21 ++-- _layouts/default.html | 38 +------ _layouts/post.html | 25 ----- atom.xml | 6 +- public/css/hyde.css | 250 +++++++++++++++++++++++++++++++++++++++++ 7 files changed, 272 insertions(+), 79 deletions(-) delete mode 100644 _layouts/post.html create mode 100644 public/css/hyde.css diff --git a/404.html b/404.html index 4bf3f7d8..9703ba81 100644 --- a/404.html +++ b/404.html @@ -6,5 +6,5 @@

404: Page not found

-

Sorry, we've misplaced that URL or it's pointing to something that doesn't exist. Head back home to try finding it again.

+

Sorry, we've misplaced that URL or it's pointing to something that doesn't exist. Head back home to try finding it again.

diff --git a/_includes/head.html b/_includes/head.html index f5af2512..fe492e52 100644 --- a/_includes/head.html +++ b/_includes/head.html @@ -10,19 +10,18 @@ {% if page.title == "Home" %} {{ site.title }} · {{ site.tagline }} {% else %} - {{ site.title }} · {{ page.title }} + {{ page.title }} · {{ site.title }} {% endif %} - - + + - - + diff --git a/_includes/sidebar.html b/_includes/sidebar.html index e29ed8b9..9dd56b0b 100644 --- a/_includes/sidebar.html +++ b/_includes/sidebar.html @@ -1,12 +1,13 @@ - - - - -
diff --git a/_layouts/default.html b/_layouts/default.html index e1ad606e..b88a066b 100644 --- a/_layouts/default.html +++ b/_layouts/default.html @@ -3,45 +3,13 @@ {% include head.html %} - + {% include sidebar.html %} - -
-
-
-

- {{ site.title }} - {{ site.tagline }} -

-
-
- -
- {{ content }} -
+
+ {{ content }}
- - - diff --git a/_layouts/post.html b/_layouts/post.html deleted file mode 100644 index c0274776..00000000 --- a/_layouts/post.html +++ /dev/null @@ -1,25 +0,0 @@ ---- -layout: default ---- - -
-

{{ page.title }}

- {{ page.date | date_to_string }} - {{ content }} -
- -
-

Related Posts

- -
diff --git a/atom.xml b/atom.xml index 15eed6ca..96c9681c 100644 --- a/atom.xml +++ b/atom.xml @@ -6,8 +6,8 @@ layout: null {{ site.title }} - - + + {{ site.time | date_to_xmlschema }} {{ site.url }} @@ -20,7 +20,7 @@ layout: null {{ post.title }} {{ post.date | date_to_xmlschema }} - {{ site.url }}{{ site.baseurl }}{{ post.id }} + {{ site.url }}{{ post.id }} {{ post.content | xml_escape }} {% endfor %} diff --git a/public/css/hyde.css b/public/css/hyde.css new file mode 100644 index 00000000..94134810 --- /dev/null +++ b/public/css/hyde.css @@ -0,0 +1,250 @@ +/* + * __ __ + * /\ \ /\ \ + * \ \ \___ __ __ \_\ \ __ + * \ \ _ `\/\ \/\ \ /'_` \ /'__`\ + * \ \ \ \ \ \ \_\ \/\ \_\ \/\ __/ + * \ \_\ \_\/`____ \ \___,_\ \____\ + * \/_/\/_/`/___/> \/__,_ /\/____/ + * /\___/ + * \/__/ + * + * Designed, built, and released under MIT license by @mdo. Learn more at + * https://github.com/poole/hyde. + */ + + +/* + * Contents + * + * Global resets + * Sidebar + * Container + * Reverse layout + * Themes + */ + + +/* + * Global resets + * + * Update the foundational and global aspects of the page. + */ + +html { + font-family: "PT Sans", Helvetica, Arial, sans-serif; +} +@media (min-width: 48em) { + html { + font-size: 16px; + } +} +@media (min-width: 58em) { + html { + font-size: 20px; + } +} + + +/* + * Sidebar + * + * Flexible banner for housing site name, intro, and "footer" content. Starts + * out above content in mobile and later moves to the side with wider viewports. + */ + +.sidebar { + text-align: center; + padding: 2rem 1rem; + color: rgba(255,255,255,.5); + background-color: #202020; +} +@media (min-width: 48em) { + .sidebar { + position: fixed; + top: 0; + left: 0; + bottom: 0; + width: 18rem; + text-align: left; + } +} + +/* Sidebar links */ +.sidebar a { + color: #fff; +} + +/* About section */ +.sidebar-about h1 { + color: #fff; + margin-top: 0; + font-family: "Abril Fatface", serif; + font-size: 2.25rem; +} + +/* Sidebar nav */ +.sidebar-nav { + margin-bottom: 1rem; +} +.sidebar-nav-item { + display: block; + line-height: 1.75; +} +a.sidebar-nav-item:hover, +a.sidebar-nav-item:focus { + text-decoration: underline; +} +.sidebar-nav-item.active { + font-weight: bold; +} + +/* Sticky sidebar + * + * Add the `sidebar-sticky` class to the sidebar's container to affix it the + * contents to the bottom of the sidebar in tablets and up. + */ + +@media (min-width: 48em) { + .sidebar-sticky { + position: absolute; + right: 1rem; + bottom: 1rem; + left: 1rem; + } +} + + +/* Container + * + * Align the contents of the site above the proper threshold with some margin-fu + * with a 25%-wide `.sidebar`. + */ + +.content { + padding-top: 4rem; + padding-bottom: 4rem; +} + +@media (min-width: 48em) { + .content { + max-width: 38rem; + margin-left: 20rem; + margin-right: 2rem; + } +} + +@media (min-width: 64em) { + .content { + margin-left: 22rem; + margin-right: 4rem; + } +} + + +/* + * Reverse layout + * + * Flip the orientation of the page by placing the `.sidebar` on the right. + */ + +@media (min-width: 48em) { + .layout-reverse .sidebar { + left: auto; + right: 0; + } + .layout-reverse .content { + margin-left: 2rem; + margin-right: 20rem; + } +} + +@media (min-width: 64em) { + .layout-reverse .content { + margin-left: 4rem; + margin-right: 22rem; + } +} + + + +/* + * Themes + * + * As of v1.1, Hyde includes optional themes to color the sidebar and links + * within blog posts. To use, add the class of your choosing to the `body`. + */ + +/* Base16 (http://chriskempson.github.io/base16/#default) */ + +/* Red */ +.theme-base-08 .sidebar { + background-color: #ac4142; +} +.theme-base-08 .content a, +.theme-base-08 .related-posts li a:hover { + color: #ac4142; +} + +/* Orange */ +.theme-base-09 .sidebar { + background-color: #d28445; +} +.theme-base-09 .content a, +.theme-base-09 .related-posts li a:hover { + color: #d28445; +} + +/* Yellow */ +.theme-base-0a .sidebar { + background-color: #f4bf75; +} +.theme-base-0a .content a, +.theme-base-0a .related-posts li a:hover { + color: #f4bf75; +} + +/* Green */ +.theme-base-0b .sidebar { + background-color: #90a959; +} +.theme-base-0b .content a, +.theme-base-0b .related-posts li a:hover { + color: #90a959; +} + +/* Cyan */ +.theme-base-0c .sidebar { + background-color: #75b5aa; +} +.theme-base-0c .content a, +.theme-base-0c .related-posts li a:hover { + color: #75b5aa; +} + +/* Blue */ +.theme-base-0d .sidebar { + background-color: #6a9fb5; +} +.theme-base-0d .content a, +.theme-base-0d .related-posts li a:hover { + color: #6a9fb5; +} + +/* Magenta */ +.theme-base-0e .sidebar { + background-color: #aa759f; +} +.theme-base-0e .content a, +.theme-base-0e .related-posts li a:hover { + color: #aa759f; +} + +/* Brown */ +.theme-base-0f .sidebar { + background-color: #8f5536; +} +.theme-base-0f .content a, +.theme-base-0f .related-posts li a:hover { + color: #8f5536; +} From 48bf7c9eef9ef095fd4aa5ec0bc86e4f00524bd6 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Mon, 11 Sep 2017 21:51:56 +0100 Subject: [PATCH 08/98] partial implementation of categories --- _config.yml | 2 +- _data/allamanistaxonomy.yml | 70 +++++-------------------------------- base-taxonomy/generative.md | 4 --- 3 files changed, 9 insertions(+), 67 deletions(-) delete mode 100644 base-taxonomy/generative.md diff --git a/_config.yml b/_config.yml index a79b978e..937868b3 100644 --- a/_config.yml +++ b/_config.yml @@ -1,5 +1,5 @@ # Setup -title: Machine Learning for Code +title: Probabilistic Models of Code tagline: 'a literature review' description: 'A survey of academic research on machine learning models for source code.' url: http://todo.com diff --git a/_data/allamanistaxonomy.yml b/_data/allamanistaxonomy.yml index d1bb914e..15f198e4 100644 --- a/_data/allamanistaxonomy.yml +++ b/_data/allamanistaxonomy.yml @@ -1,63 +1,9 @@ ---- - bibkey: allamanis2013mining - categories: [generative] - type: lm - representation: Tokens - model: n-gram LM - ---- - bibkey: allamanis2014learning - categories: [generative] - type: lm - representation: Tokens - model: n-gram LM - application: Coding Conventions - ---- - bibkey: allamanis2014mining - categories: [generative, pattern] - type: lm - representation: AST - model: pTSG - application: Idiom Mining - ---- - bibkey: allamanis2015bimodal - categories: [generative] - type: multimodal - representation: AST - model: Neural LM - application: Code Search/Synthesis - ---- - bibkey: allamanis2015suggesting - categories: [representational] - representation: distributed - application: Naming Conventions - input_rep: Token Context - target_rep: Identifier Name - ---- - bibkey: allamanis2016convolutional - categories: [representational] - representation: Tokens - application: Method Naming Conventions - input_rep: Token - target_rep: Method Name - ---- - bibkey: allamanis2017mining - categories: [generative, pattern] - type: lm - representation: AST - model: pTSG - application: Idiom Mining - ---- - bibkey: allamanis2017smartpaste - categories: [representational] - representation: Distributed - application: Code Contextualization and Bug Finding - input_rep: Data Flow - target_rep: Variable Allocation +- {bibkey: allamanis2013mining, categories: [generative], type: lm, representation: Tokens, model: n-gram LM} +- {bibkey: allamanis2014learning, categories: [generative], type: lm, representation: Tokens, model: n-gram LM, application: Coding Conventions} +- {bibkey: allamanis2014mining, categories: [generative, pattern], type: lm, representation: AST, model: pTSG, application: Idiom Mining} +- {bibkey: allamanis2015bimodal, categories: [generative], type: multimodal, representation: AST, model: Neural LM, application: Code Search/Synthesis} +- {bibkey: allamanis2015suggesting, categories: [representational], representation: distributed, application: Naming Conventions, input_rep: Token Context, target_rep: Identifier Name} +- {bibkey: allamanis2016convolutional, categories: [representational], representation: Tokens, application: Method Naming Conventions, input_rep: Token, target_rep: Method Name} +- {bibkey: allamanis2017mining, categories: [generative, pattern], type: lm, representation: AST, model: pTSG, application: Idiom Mining} +- {bibkey: allamanis2017smartpaste, categories: [representational], representation: Distributed, application: Code Contextualization and Bug Finding, input_rep: Data Flow, target_rep: Variable Allocation} diff --git a/base-taxonomy/generative.md b/base-taxonomy/generative.md deleted file mode 100644 index fc74651b..00000000 --- a/base-taxonomy/generative.md +++ /dev/null @@ -1,4 +0,0 @@ ---- -layout: page -title: Code-Generating Models ---- From 2546cbe415e6ccff2eb7777bbc2252164bd74665 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Mon, 11 Sep 2017 22:21:49 +0100 Subject: [PATCH 09/98] Added generative models. --- _data/allamanistaxonomy.yml | 58 +++++++++++++++++++++++++++++------ base-taxonomy/generative.html | 21 +++++++++++++ public/css/hyde.css | 4 +++ 3 files changed, 74 insertions(+), 9 deletions(-) create mode 100644 base-taxonomy/generative.html diff --git a/_data/allamanistaxonomy.yml b/_data/allamanistaxonomy.yml index 15f198e4..42ad0a98 100644 --- a/_data/allamanistaxonomy.yml +++ b/_data/allamanistaxonomy.yml @@ -1,9 +1,49 @@ -- {bibkey: allamanis2013mining, categories: [generative], type: lm, representation: Tokens, model: n-gram LM} -- {bibkey: allamanis2014learning, categories: [generative], type: lm, representation: Tokens, model: n-gram LM, application: Coding Conventions} -- {bibkey: allamanis2014mining, categories: [generative, pattern], type: lm, representation: AST, model: pTSG, application: Idiom Mining} -- {bibkey: allamanis2015bimodal, categories: [generative], type: multimodal, representation: AST, model: Neural LM, application: Code Search/Synthesis} -- {bibkey: allamanis2015suggesting, categories: [representational], representation: distributed, application: Naming Conventions, input_rep: Token Context, target_rep: Identifier Name} -- {bibkey: allamanis2016convolutional, categories: [representational], representation: Tokens, application: Method Naming Conventions, input_rep: Token, target_rep: Method Name} -- {bibkey: allamanis2017mining, categories: [generative, pattern], type: lm, representation: AST, model: pTSG, application: Idiom Mining} -- {bibkey: allamanis2017smartpaste, categories: [representational], representation: Distributed, application: Code Contextualization and Bug Finding, input_rep: Data Flow, target_rep: Variable Allocation} - +- {bibkey: aggarwal2015using, categories: [generative], type: Transducer, representation: Token , model: Phrase , application: Migration} +- {bibkey: allamanis2013mining, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: --- } +- {bibkey: allamanis2014learning, categories: [generative], type: Language Model, representation: Token + Location, model: n-gram, application: Coding Conventions} +- {bibkey: allamanis2014mining, categories: [generative], type: Language Model, representation: Syntax , model: Grammar (pTSG) , application: ---} +- {bibkey: allamanis2015bimodal, categories: [generative], type: Multimodal, representation: Syntax , model: Grammar (NN-LBL), application: Code Search/Synthesis} +- {bibkey: amodio2017neural, categories: [generative], type: Language Model, representation: Syntax+Constraints , model: RNN , application: ---} +- {bibkey: barone2017parallel, categories: [generative], type: Multimodal, representation: Token , model: Neural MT , application: Documentation} +- {bibkey: beltramelli2017pix2code, categories: [generative], type: Multimodal, representation: Token , model: NN (Encoder-Decoder) , application: GUI Code Synthesis} +- {bibkey: bhatia2016automated, categories: [generative], type: Language Model, representation: Token , model: RNN (LSTM) , application: Syntax Error Correction} +- {bibkey: bhoopchand2016learning, categories: [generative], type: Language Model, representation: Token , model: NN (Pointer Net) , application: Code Completion } +- {bibkey: bielik2016phog, categories: [generative], type: Language Model, representation: Syntax , model: PCFG + annotations , application: Code Completion} +- {bibkey: campbell2014syntax, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Syntax Error Detection } +- {bibkey: cerulo2015irish, categories: [generative], type: Language Model, representation: Token , model: Graphical Model (HMM) , application: Information Extraction} +- {bibkey: cummins2017synthesizing, categories: [generative], type: Language Model, representation: Character , model: NN (LSTM) , application: Benchmark Synthesis} +- {bibkey: dam2016deep, categories: [generative], type: Language Model, representation: Token , model: NN (LSTM), application: ---} +- {bibkey: gulwani2014nlyze, categories: [generative], type: Multimodal, representation: Syntax , model: Phrase Model , application: Text-to-Code } +- {bibkey: gvero2015synthesizing, categories: [generative], type: Language Model, representation: Syntax , model: PCFG + Search , application: Code Synthesis} +- {bibkey: hellendoorn2015will, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Code Review} +- {bibkey: hellendoorn2017deep, categories: [generative], type: Language Model, representation: token , model: n-gram (cache) , application: -- } +- {bibkey: hindle2012naturalness, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Code Completion} +- {bibkey: hsiao2014using, categories: [generative], type: Language Model, representation: PDG , model: n-gram , application: Program Analysis} +- {bibkey: lin2017program, categories: [generative], type: Multimodal, representation: Tokens , model: NN (Seq2seq) , application: Synthesis} +- {bibkey: ling2016latent, categories: [generative], type: Multimodal, representation: Token , model: RNN + Attention , application: Code Synthesis} +- {bibkey: liu2016towards, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Obfuscation} +- {bibkey: karaivanov2014phrase, categories: [generative], type: Transducer, representation: Token , model: Phrase , application: Migration} +- {bibkey: karpathy2015visualizing, categories: [generative], type: Language Model, representation: Characters , model: RNN (LSTM), application: ---} +- {bibkey: kushman2013using, categories: [generative], type: Multimodal, representation: Token , model: Grammar (CCG) , application: Code Synthesis} +- {bibkey: maddison2014structured, categories: [generative], type: Language Model, representation: Syntax with scope , model: NN , application: --- } +- {bibkey: menon2013machine, categories: [generative], type: Multimodal, representation: Syntax , model: PCFG + annotations , application: Code Synthesis} +- {bibkey: nguyen2013lexical, categories: [generative], type: Transducer, representation: Token , model: Phrase , application: Migration} +- {bibkey: nguyen2013statistical, categories: [generative], type: Language Model, representation: Token + parse info , model: n-gram , application: Code Completion} +- {bibkey: nguyen2015divide, categories: [generative], type: Transducer, representation: Token + parse info , model: Phrase SMT , application: Migration} +- {bibkey: nguyen2015graph, categories: [generative], type: Language Model, representation: Partial PDG , model: n-gram , application: Code Completion} +- {bibkey: oda2015learning, categories: [generative], type: Transducer, representation: Syntax + Token , model: Tree-to-String + Phrase , application: Pseudocode Generation} +- {bibkey: patra2016learning, categories: [generative], type: Language Model, representation: Syntax , model: Annotated PCFG , application: Fuzz Testing} +- {bibkey: pham2016learning, categories: [generative], type: Language Model, representation: Bytecode , model: Graphical Model (HMM) , application: Code Completion} +- {bibkey: pu2016skp, categories: [generative], type: Transducer, representation: Token , model: NN (Seq2seq) , application: Code Fixing} +- {bibkey: rabinovich2017abstract, categories: [generative], type: Multimodal, representation: Syntax , model: NN (LSTM-based), application: Code Synthesis} +- {bibkey: raychev2014code, categories: [generative], type: Language Model, representation: Token + Constraints , model: n-gram/ RNN , application: Code Completion} +- {bibkey: ray2015naturalness, categories: [generative], type: Language Model, representation: Token , model: n-gram (cache) , application: Bug Detection} +- {bibkey: raychev2016learning, categories: [generative], type: Language Model, representation: Syntax , model: PCFG + annotations , application: Code Completion} +- {bibkey: saraiva2015products, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: ---} +- {bibkey: sharma2015nirmal, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Information Extraction} +- {bibkey: tu2014localness, categories: [generative], type: Language Model, representation: Token , model: n-gram (cache) , application: Code Completion} +- {bibkey: vasilescu2017recovering, categories: [generative], type: Transducer, representation: Token , model: , application: Deobfuscation} +- {bibkey: wang2016neural, categories: [generative], type: Language Model, representation: Syntax , model: NN (LSTM), application: Code Completion } +- {bibkey: white2015toward, categories: [generative], type: Language Model, representation: Token , model: NN (RNN) , application: ---} +- {bibkey: yadid2016extracting, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Information Extraction} +- {bibkey: yin2017syntactic, categories: [generative], type: Multimodal, representation: Syntax , model: NN (Seq2seq) , application: Synthesis} diff --git a/base-taxonomy/generative.html b/base-taxonomy/generative.html new file mode 100644 index 00000000..99b9decd --- /dev/null +++ b/base-taxonomy/generative.html @@ -0,0 +1,21 @@ +--- +layout: default +title: Code-Generating Models +--- +

Code-Generating Models

+ +{% assign publicationsList = site.data.allamanistaxonomy | order_by:"bibkey" %} + + +{% for publication in publicationsList %}{% if publication.categories contains "generative" %} + {% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} + + + + + + + + +{% endif %}{% endfor %} +
NameTypeRepresentationModelApplication
{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}}{{publication.type}}{{publication.representation}}{{publication.model}}{{publication.application}}
\ No newline at end of file diff --git a/public/css/hyde.css b/public/css/hyde.css index 94134810..aafa2f5c 100644 --- a/public/css/hyde.css +++ b/public/css/hyde.css @@ -141,6 +141,10 @@ a.sidebar-nav-item:focus { } } +td { + font-size:15px; +} + /* * Reverse layout From d6b96caaef07f7d3e79b724ec84299465f3668bc Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Mon, 11 Sep 2017 22:33:01 +0100 Subject: [PATCH 10/98] Added pattern models. --- _data/allamanistaxonomy.yml | 16 ++++++++++++++-- base-taxonomy/pattern.html | 20 ++++++++++++++++++++ base-taxonomy/pattern.md | 4 ---- 3 files changed, 34 insertions(+), 6 deletions(-) create mode 100644 base-taxonomy/pattern.html delete mode 100644 base-taxonomy/pattern.md diff --git a/_data/allamanistaxonomy.yml b/_data/allamanistaxonomy.yml index 42ad0a98..8de302ab 100644 --- a/_data/allamanistaxonomy.yml +++ b/_data/allamanistaxonomy.yml @@ -1,7 +1,8 @@ +# Generative Models - {bibkey: aggarwal2015using, categories: [generative], type: Transducer, representation: Token , model: Phrase , application: Migration} -- {bibkey: allamanis2013mining, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: --- } +- {bibkey: allamanis2013mining, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Idiom Mining } - {bibkey: allamanis2014learning, categories: [generative], type: Language Model, representation: Token + Location, model: n-gram, application: Coding Conventions} -- {bibkey: allamanis2014mining, categories: [generative], type: Language Model, representation: Syntax , model: Grammar (pTSG) , application: ---} +- {bibkey: allamanis2014mining, categories: [generative, pattern], type: Language Model, pattern_type: Graphical Model, representation: Syntax , model: Grammar (pTSG) , application: ---} - {bibkey: allamanis2015bimodal, categories: [generative], type: Multimodal, representation: Syntax , model: Grammar (NN-LBL), application: Code Search/Synthesis} - {bibkey: amodio2017neural, categories: [generative], type: Language Model, representation: Syntax+Constraints , model: RNN , application: ---} - {bibkey: barone2017parallel, categories: [generative], type: Multimodal, representation: Token , model: Neural MT , application: Documentation} @@ -47,3 +48,14 @@ - {bibkey: white2015toward, categories: [generative], type: Language Model, representation: Token , model: NN (RNN) , application: ---} - {bibkey: yadid2016extracting, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Information Extraction} - {bibkey: yin2017syntactic, categories: [generative], type: Multimodal, representation: Syntax , model: NN (Seq2seq) , application: Synthesis} + +# Pattern Models +- {bibtex: allamanis2016mining, categories: [pattern], representation: Abstracted AST , pattern_type: Graphical Model , application: Semantic Idiom Mining } +- {bibtex: fowkes2015parameter, categories: [pattern], representation: API Call Sequences , pattern_type: Graphical Model , application: API Mining } +- {bibtex: murali2017bayesian, categories: [pattern], representation: Sketch Synthesis , pattern_type: Graphical Model , application: Sketch Mining } +- {bibtex: murali2017finding, categories: [pattern], representation: API Usage Errors , pattern_type: Graphical Model , application: Defect Prediction } +- {bibtex: movshovitz2015kb, categories: [pattern], representation: Tokens , pattern_type: Graphical Model , application: Knowledge-Base Mining } +- {bibtex: nguyen2017exploring, categories: [pattern], representation: API Usage , pattern_type: Distributed , application: API Mining } +- {bibtex: fowkes2017autofolding, categories: [pattern], representation: Tokens , pattern_type: Graphical Model , application: Code Summarization } +- {bibtex: wang2016automatically, categories: [pattern], representation: Serialized ASTs , pattern_type: Distributed , application: Defect Prediction } +- {bibtex: white2016deep, categories: [pattern], representation: Token + Syntax , pattern_type: Distributed , application: Clone Detection } \ No newline at end of file diff --git a/base-taxonomy/pattern.html b/base-taxonomy/pattern.html new file mode 100644 index 00000000..bfae6884 --- /dev/null +++ b/base-taxonomy/pattern.html @@ -0,0 +1,20 @@ +--- +layout: default +title: Pattern-Mining Models +--- +

Pattern Mining Models

+ +{% assign publicationsList = site.data.allamanistaxonomy | order_by:"bibkey" %} + + +{% for publication in publicationsList %}{% if publication.categories contains "pattern" %} + {% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} + + + + + + + +{% endif %}{% endfor %} +
NameTypeRepresentationApplication
{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}}{{publication.pattern_type}}{{publication.representation}}{{publication.application}}
\ No newline at end of file diff --git a/base-taxonomy/pattern.md b/base-taxonomy/pattern.md deleted file mode 100644 index 7bdcf547..00000000 --- a/base-taxonomy/pattern.md +++ /dev/null @@ -1,4 +0,0 @@ ---- -layout: page -title: Pattern Mining Models ---- From d5f30c654549ed19bf6d946d7fe865ea9e0c7b1e Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Mon, 11 Sep 2017 22:50:21 +0100 Subject: [PATCH 11/98] Added papers in multiple categories and template for representational. --- _data/allamanistaxonomy.yml | 14 ++++++++------ base-taxonomy/representational.html | 21 +++++++++++++++++++++ base-taxonomy/representational.md | 4 ---- 3 files changed, 29 insertions(+), 10 deletions(-) create mode 100644 base-taxonomy/representational.html delete mode 100644 base-taxonomy/representational.md diff --git a/_data/allamanistaxonomy.yml b/_data/allamanistaxonomy.yml index 8de302ab..15022c42 100644 --- a/_data/allamanistaxonomy.yml +++ b/_data/allamanistaxonomy.yml @@ -1,9 +1,16 @@ +# In multiple categories +- {bibkey: allamanis2015bimodal, categories: [generative, representational], type: Multimodal, representation: Syntax, input_rep: Natural language, modeled_target: Language Model, intermediate_rep: Distributed, model: Grammar (NN-LBL), application: Code Search/Synthesis} +- {bibkey: dam2016deep, categories: [generative, representational], type: Language Model, representation: Token , input_rep: Token Context, modeled_target: LM (Tokens), intermediate_rep: Distributed, model: NN (LSTM), application: ---} +- {bibkey: maddison2014structured, categories: [generative, representational], type: Language Model, representation: Syntax with scope , input_rep: LM AST Context, modeled_target: Language Model, intermediate_rep: Distributed, model: NN , application: --- } +- {bibkey: rabinovich2017abstract, categories: [generative, representational], type: Multimodal, representation: Syntax , input_rep: LM AST context, modeled_target: LM (Syntax), intermediate_rep: Distributed, model: NN (LSTM-based), application: Code Synthesis} +- {bibkey: white2015toward, categories: [generative, representational], type: Language Model, representation: Token , input_rep: Tokens, modeled_target: Language Model, model: NN (RNN) , intermediate_rep: Distributed, application: ---} +- {bibtex: white2016deep, categories: [representational, pattern], representation: Token + Syntax , pattern_type: Distributed, input_rep: Token + AST, intermediate_rep: Distributed, application: Clone Detection } + # Generative Models - {bibkey: aggarwal2015using, categories: [generative], type: Transducer, representation: Token , model: Phrase , application: Migration} - {bibkey: allamanis2013mining, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Idiom Mining } - {bibkey: allamanis2014learning, categories: [generative], type: Language Model, representation: Token + Location, model: n-gram, application: Coding Conventions} - {bibkey: allamanis2014mining, categories: [generative, pattern], type: Language Model, pattern_type: Graphical Model, representation: Syntax , model: Grammar (pTSG) , application: ---} -- {bibkey: allamanis2015bimodal, categories: [generative], type: Multimodal, representation: Syntax , model: Grammar (NN-LBL), application: Code Search/Synthesis} - {bibkey: amodio2017neural, categories: [generative], type: Language Model, representation: Syntax+Constraints , model: RNN , application: ---} - {bibkey: barone2017parallel, categories: [generative], type: Multimodal, representation: Token , model: Neural MT , application: Documentation} - {bibkey: beltramelli2017pix2code, categories: [generative], type: Multimodal, representation: Token , model: NN (Encoder-Decoder) , application: GUI Code Synthesis} @@ -13,7 +20,6 @@ - {bibkey: campbell2014syntax, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Syntax Error Detection } - {bibkey: cerulo2015irish, categories: [generative], type: Language Model, representation: Token , model: Graphical Model (HMM) , application: Information Extraction} - {bibkey: cummins2017synthesizing, categories: [generative], type: Language Model, representation: Character , model: NN (LSTM) , application: Benchmark Synthesis} -- {bibkey: dam2016deep, categories: [generative], type: Language Model, representation: Token , model: NN (LSTM), application: ---} - {bibkey: gulwani2014nlyze, categories: [generative], type: Multimodal, representation: Syntax , model: Phrase Model , application: Text-to-Code } - {bibkey: gvero2015synthesizing, categories: [generative], type: Language Model, representation: Syntax , model: PCFG + Search , application: Code Synthesis} - {bibkey: hellendoorn2015will, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Code Review} @@ -26,7 +32,6 @@ - {bibkey: karaivanov2014phrase, categories: [generative], type: Transducer, representation: Token , model: Phrase , application: Migration} - {bibkey: karpathy2015visualizing, categories: [generative], type: Language Model, representation: Characters , model: RNN (LSTM), application: ---} - {bibkey: kushman2013using, categories: [generative], type: Multimodal, representation: Token , model: Grammar (CCG) , application: Code Synthesis} -- {bibkey: maddison2014structured, categories: [generative], type: Language Model, representation: Syntax with scope , model: NN , application: --- } - {bibkey: menon2013machine, categories: [generative], type: Multimodal, representation: Syntax , model: PCFG + annotations , application: Code Synthesis} - {bibkey: nguyen2013lexical, categories: [generative], type: Transducer, representation: Token , model: Phrase , application: Migration} - {bibkey: nguyen2013statistical, categories: [generative], type: Language Model, representation: Token + parse info , model: n-gram , application: Code Completion} @@ -36,7 +41,6 @@ - {bibkey: patra2016learning, categories: [generative], type: Language Model, representation: Syntax , model: Annotated PCFG , application: Fuzz Testing} - {bibkey: pham2016learning, categories: [generative], type: Language Model, representation: Bytecode , model: Graphical Model (HMM) , application: Code Completion} - {bibkey: pu2016skp, categories: [generative], type: Transducer, representation: Token , model: NN (Seq2seq) , application: Code Fixing} -- {bibkey: rabinovich2017abstract, categories: [generative], type: Multimodal, representation: Syntax , model: NN (LSTM-based), application: Code Synthesis} - {bibkey: raychev2014code, categories: [generative], type: Language Model, representation: Token + Constraints , model: n-gram/ RNN , application: Code Completion} - {bibkey: ray2015naturalness, categories: [generative], type: Language Model, representation: Token , model: n-gram (cache) , application: Bug Detection} - {bibkey: raychev2016learning, categories: [generative], type: Language Model, representation: Syntax , model: PCFG + annotations , application: Code Completion} @@ -45,7 +49,6 @@ - {bibkey: tu2014localness, categories: [generative], type: Language Model, representation: Token , model: n-gram (cache) , application: Code Completion} - {bibkey: vasilescu2017recovering, categories: [generative], type: Transducer, representation: Token , model: , application: Deobfuscation} - {bibkey: wang2016neural, categories: [generative], type: Language Model, representation: Syntax , model: NN (LSTM), application: Code Completion } -- {bibkey: white2015toward, categories: [generative], type: Language Model, representation: Token , model: NN (RNN) , application: ---} - {bibkey: yadid2016extracting, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Information Extraction} - {bibkey: yin2017syntactic, categories: [generative], type: Multimodal, representation: Syntax , model: NN (Seq2seq) , application: Synthesis} @@ -58,4 +61,3 @@ - {bibtex: nguyen2017exploring, categories: [pattern], representation: API Usage , pattern_type: Distributed , application: API Mining } - {bibtex: fowkes2017autofolding, categories: [pattern], representation: Tokens , pattern_type: Graphical Model , application: Code Summarization } - {bibtex: wang2016automatically, categories: [pattern], representation: Serialized ASTs , pattern_type: Distributed , application: Defect Prediction } -- {bibtex: white2016deep, categories: [pattern], representation: Token + Syntax , pattern_type: Distributed , application: Clone Detection } \ No newline at end of file diff --git a/base-taxonomy/representational.html b/base-taxonomy/representational.html new file mode 100644 index 00000000..f0b80748 --- /dev/null +++ b/base-taxonomy/representational.html @@ -0,0 +1,21 @@ +--- +layout: default +title: Representational Models +--- +

Representational Models

+ +{% assign publicationsList = site.data.allamanistaxonomy | order_by:"bibkey" %} + + +{% for publication in publicationsList %}{% if publication.categories contains "representational" %} + {% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} + + + + + + + + +{% endif %}{% endfor %} +
NameInput Code RepresentationTargetIntermediate RepresentationApplication
{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}}{{publication.input_rep}}{{publication.modeled_target}}{{publication.intermediate_rep}}{{publication.application}}
\ No newline at end of file diff --git a/base-taxonomy/representational.md b/base-taxonomy/representational.md deleted file mode 100644 index 17afc228..00000000 --- a/base-taxonomy/representational.md +++ /dev/null @@ -1,4 +0,0 @@ ---- -layout: page -title: Representational Models ---- From 6c44008bc08bfeeb942b8ab54e3792e698688ff6 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Mon, 11 Sep 2017 22:55:39 +0100 Subject: [PATCH 12/98] Fix sorting problem. --- base-taxonomy/generative.html | 5 +++-- base-taxonomy/pattern.html | 2 +- base-taxonomy/representational.html | 2 +- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/base-taxonomy/generative.html b/base-taxonomy/generative.html index 99b9decd..82e8e9b2 100644 --- a/base-taxonomy/generative.html +++ b/base-taxonomy/generative.html @@ -4,14 +4,15 @@ ---

Code-Generating Models

-{% assign publicationsList = site.data.allamanistaxonomy | order_by:"bibkey" %} +{% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %} + {% for publication in publicationsList %}{% if publication.categories contains "generative" %} {% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} - + diff --git a/base-taxonomy/pattern.html b/base-taxonomy/pattern.html index bfae6884..165e050c 100644 --- a/base-taxonomy/pattern.html +++ b/base-taxonomy/pattern.html @@ -4,7 +4,7 @@ ---

Pattern Mining Models

-{% assign publicationsList = site.data.allamanistaxonomy | order_by:"bibkey" %} +{% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %}
NameTypeRepresentationModelApplication
{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}}{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}} {{publication.type}} {{publication.representation}} {{publication.model}}
{% for publication in publicationsList %}{% if publication.categories contains "pattern" %} diff --git a/base-taxonomy/representational.html b/base-taxonomy/representational.html index f0b80748..5509d1d3 100644 --- a/base-taxonomy/representational.html +++ b/base-taxonomy/representational.html @@ -4,7 +4,7 @@ ---

Representational Models

-{% assign publicationsList = site.data.allamanistaxonomy | order_by:"bibkey" %} +{% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %}
NameTypeRepresentationApplication
{% for publication in publicationsList %}{% if publication.categories contains "representational" %} From 468b6767b7e997f6633dfd3711a5ed547ecc661a Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Mon, 11 Sep 2017 22:59:59 +0100 Subject: [PATCH 13/98] Add representational models. --- _data/allamanistaxonomy.yml | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/_data/allamanistaxonomy.yml b/_data/allamanistaxonomy.yml index 15022c42..e54a8f48 100644 --- a/_data/allamanistaxonomy.yml +++ b/_data/allamanistaxonomy.yml @@ -52,6 +52,38 @@ - {bibkey: yadid2016extracting, categories: [generative], type: Language Model, representation: Token , model: n-gram , application: Information Extraction} - {bibkey: yin2017syntactic, categories: [generative], type: Multimodal, representation: Syntax , model: NN (Seq2seq) , application: Synthesis} +# Representational Models +- {bibtex: allamanis2015suggesting, categories: [representational], input_rep: Token Context , modeled_target: Identifier Name , intermediate_rep: Distributed , application: Naming } +- {bibtex: allamanis2016convolutional, categories: [representational], input_rep: Tokens , modeled_target: Method Name , intermediate_rep: Distributed , application: Naming } +- {bibtex: allamanis2017smartpaste, categories: [representational], input_rep: Data Flow , modeled_target: Variable Allocation , intermediate_rep: Distributed , application: Contextualization } +- {bibtex: bichsel2016statistical, categories: [representational], input_rep: Dependency Net , modeled_target: Identifier Name , intermediate_rep: CRF (GM) , application: Deobfuscation } +- {bibtex: bruch2009learning, categories: [representational], input_rep: Partial Object Use , modeled_target: Invoked Method , intermediate_rep: Localized , application: Code Completion } +- {bibtex: chae2016automatically, categories: [representational], input_rep: Data Flow Graph , modeled_target: Static Analysis , intermediate_rep: Localized , application: Program Analysis } +- {bibtex: corley2015exploring, categories: [representational], input_rep: Tokens , modeled_target: Feature Location , intermediate_rep: Distributed , application: Feature Location } +- {bibtex: cummins2017end, categories: [representational], input_rep: Tokens , modeled_target: Optimization Flags , intermediate_rep: Distributed , application: Optimization Heuristics } +- {bibtex: green2017learning, categories: [representational], input_rep: Statements, modeled_target: Alignment , intermediate_rep: Distributed , application: Decompiling } +- {bibtex: gu2016deep, categories: [representational], input_rep: Natural Language , modeled_target: API Calls , intermediate_rep: Distributed , application: API Search } +- {bibtex: guo2017semantically, categories: [representational], input_rep: Tokens , modeled_target: Traceability link , intermediate_rep: Distributed , application: Traceability } +- {bibtex: gupta2016deepfix, categories: [representational], input_rep: Tokens , modeled_target: Code Fix , intermediate_rep: Distributed , application: Code Fixing } +- {bibtex: hu2017codesum, categories: [representational], input_rep: Linearized AST , modeled_target: Natural Language , intermediate_rep: Distributed , application: Summarization } +- {bibtex: iyer2016summarizing, categories: [representational], input_rep: Tokens , modeled_target: Natural Language , intermediate_rep: Distributed , application: Summarization } +- {bibtex: jiang2017automatically, categories: [representational], input_rep: Tokens (Diff) , modeled_target: Natural Language , intermediate_rep: Distributed , application: Commit Message } +- {bibtex: koc2017learning, categories: [representational], input_rep: Bytecode , modeled_target: False Positives , intermediate_rep: Distributed , application: Program Analysis } +- {bibtex: kremenek2007factor, categories: [representational], input_rep: Partial PDG , modeled_target: Ownership , intermediate_rep: Factor (GM) , application: Pointer Ownership } +- {bibtex: loyola2017neural, categories: [representational], input_rep: Tokens (Diff) , modeled_target: Natural Language , intermediate_rep: Distributed , application: Explain code changes } +- {bibtex: li2015gated, categories: [representational], input_rep: Memory Heap , modeled_target: Separation Logic , intermediate_rep: Distributed , application: Verification } +- {bibtex: mangal2015user, categories: [representational], input_rep: Logic + Feedback , modeled_target: Prob. Analysis , intermediate_rep: MaxSAT , application: Program Analysis } +- {bibtex: movshovitz2013natural, categories: [representational], input_rep: Tokens , modeled_target: Code Comments , intermediate_rep: Directed GM , application: Comment Prediction } +- {bibtex: mou2016convolutional, categories: [representational], input_rep: Syntax , modeled_target: Classification , intermediate_rep: Distributed , application: Task Classification } +- {bibtex: nguyen2016mapping, categories: [representational], input_rep: API Calls , modeled_target: API Calls , intermediate_rep: Distributed , application: Migration } +- {bibtex: omar2013structured, categories: [representational], input_rep: Syntactic Context , modeled_target: Expressions , intermediate_rep: Directed GM , application: Code Completion } +- {bibtex: oh2015learning, categories: [representational], input_rep: Features , modeled_target: Analysis Params , intermediate_rep: Static Analysis , application: Program Analysis } +- {bibtex: piech2015learning, categories: [representational], input_rep: Syntax + State , modeled_target: Student Feedback , intermediate_rep: Distributed , application: Student Feedback } +- {bibtex: proksch2015intelligent, categories: [representational], input_rep: Inc. Object Usage , modeled_target: Object Usage , intermediate_rep: Directed GM , application: Code Completion } +- {bibtex: raychev2015predicting, categories: [representational], input_rep: Dependency Net , modeled_target: Types + Names , intermediate_rep: CRF (GM) , application: Types + Names } +- {bibtex: wang2016bugram, categories: [representational], input_rep: Tokens , modeled_target: Defects , intermediate_rep: LM (\ngram) , application: Bug Detection } +- {bibtex: zaremba2014learning, categories: [representational], input_rep: Characters , modeled_target: Execution Trace , intermediate_rep: Distributed , application: --- } + # Pattern Models - {bibtex: allamanis2016mining, categories: [pattern], representation: Abstracted AST , pattern_type: Graphical Model , application: Semantic Idiom Mining } - {bibtex: fowkes2015parameter, categories: [pattern], representation: API Call Sequences , pattern_type: Graphical Model , application: API Mining } From 40fa50ed3590df007a983fd9f041bd364d90653c Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Mon, 11 Sep 2017 23:32:37 +0100 Subject: [PATCH 14/98] Added some publications. --- _layouts/publication.html | 1 - _publications/aggarwal2015using.markdown | 9 +++++++++ _publications/amodio2017neural.markdown | 10 ++++++++++ _publications/bhatia2016automated.markdown | 10 ++++++++++ _publications/bielik2016phog.markdown | 9 +++++++++ _publications/bruch2009learning.markdown | 10 ++++++++++ _publications/campbell2014syntax.markdown | 10 ++++++++++ _publications/cerulo2013hidden.markdown | 15 +++++++++++++++ _publications/cerulo2015irish.markdown | 14 ++++++++++++++ _publications/corley2015exploring.markdown | 9 +++++++++ _publications/cummins2017end.markdown | 13 +++++++++++++ base-taxonomy/generative.html | 1 - base-taxonomy/pattern.html | 2 +- base-taxonomy/representational.html | 2 +- papers.html | 2 +- 15 files changed, 112 insertions(+), 5 deletions(-) create mode 100644 _publications/aggarwal2015using.markdown create mode 100644 _publications/amodio2017neural.markdown create mode 100644 _publications/bhatia2016automated.markdown create mode 100644 _publications/bielik2016phog.markdown create mode 100644 _publications/bruch2009learning.markdown create mode 100644 _publications/campbell2014syntax.markdown create mode 100644 _publications/cerulo2013hidden.markdown create mode 100644 _publications/cerulo2015irish.markdown create mode 100644 _publications/corley2015exploring.markdown create mode 100644 _publications/cummins2017end.markdown diff --git a/_layouts/publication.html b/_layouts/publication.html index b840111f..49490960 100644 --- a/_layouts/publication.html +++ b/_layouts/publication.html @@ -5,7 +5,6 @@

{{ page.title }}

{{ page.authors }}. {{ page.conference }} {{ page.year }}
-

[pdf] {% for additional_link in page.additional_links %} [{{ additional_link.name }}] {% endfor %} diff --git a/_publications/aggarwal2015using.markdown b/_publications/aggarwal2015using.markdown new file mode 100644 index 00000000..aa2fdd80 --- /dev/null +++ b/_publications/aggarwal2015using.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Using Machine Translation for Converting Python 2 to Python 3 Code" +authors: K. Aggarwal, M. Salameh, and A. Hindle +conference: +year: 2015 +bibkey: aggarwal2015using +--- +In this paper, we have tried to use Statistical machine translation in order to convert Python 2 code to Python 3 code. We use data from two projects and achieve a high BLEU score. We also investigate the cross-project training and testing to analyze the errors so as to ascertain differences with previous case. We have described a pilot study on modeling programming languages as natural language to build translation models on the lines of natural languages. This can be further worked on to translate between versions of a programming language or cross-programming-languages code translation. diff --git a/_publications/amodio2017neural.markdown b/_publications/amodio2017neural.markdown new file mode 100644 index 00000000..0b081f37 --- /dev/null +++ b/_publications/amodio2017neural.markdown @@ -0,0 +1,10 @@ +--- +layout: publication +title: "Neural Attribute Machines for Program Generation" +authors: M. Amodio, S. Chaudhuri, T. Reps +conference: +year: 2017 +bibkey: amodio2016neural +--- +Recurrent neural networks have achieved remarkable success at generating sequences with complex structures, thanks to advances that include richer embeddings of input and cures for vanishing gradients. Trained only on sequences from a known grammar, though, they can still struggle to learn rules and constraints of the grammar. Neural Attribute Machines (NAMs) are equipped with a logical machine that represents the underlying grammar, which is used to teach the constraints to the neural machine by (i) augmenting the input sequence, and (ii) optimizing a custom loss function. Unlike traditional RNNs, NAMs are exposed to the grammar, as well as samples from the language of the grammar. During generation, NAMs make significantly fewer violations of the constraints of the underlying grammar than RNNs trained only on samples from the language of the grammar. + diff --git a/_publications/bhatia2016automated.markdown b/_publications/bhatia2016automated.markdown new file mode 100644 index 00000000..c558f763 --- /dev/null +++ b/_publications/bhatia2016automated.markdown @@ -0,0 +1,10 @@ +--- +layout: publication +title: "Automated Correction for Syntax Errors in Programming Assignments using Recurrent Neural Networks" +authors: S. Bhatia, R. Singh +conference: +year: 2016 +bibkey: bhatia2016automated +--- +We present a method for automatically generating repair feedback for syntax errors for introductory programming problems. Syntax errors constitute one of the largest classes of errors (34%) in our dataset of student submissions obtained from a MOOC course on edX. The previous techniques for generating automated feedback on programming assignments have focused on functional correctness and style considerations of student programs. These techniques analyze the program AST of the program and then perform some dynamic and symbolic analyses to compute repair feedback. Unfortunately, it is not possible to generate ASTs for student programs with syntax errors and therefore the previous feedback techniques are not applicable in repairing syntax errors. We present a technique for providing feedback on syntax errors that uses Recurrent neural networks (RNNs) to model syntactically valid token sequences. Our approach is inspired from the recent work on learning language models from Big Code (large code corpus). For a given programming assignment, we first learn an RNN to model all valid token sequences using the set of syntactically correct student submissions. Then, for a student submission with +syntax errors, we query the learnt RNN model with the prefix token sequence to predict token sequences that can fix the error by either replacing or inserting the predicted token sequence at the error location. We evaluate our technique on over 14, 000 student submissions with syntax errors. Our technique can completely repair 31.69% (4501/14203) of submissions with syntax errors and in addition partially correct 6.39% (908/14203) of the submissions. diff --git a/_publications/bielik2016phog.markdown b/_publications/bielik2016phog.markdown new file mode 100644 index 00000000..92f85704 --- /dev/null +++ b/_publications/bielik2016phog.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "PHOG: Probabilistic Model for Code" +authors: P. Bielik, V. Raychev, M. Vechev +conference: ICML +year: 2016 +bibkey: bielik2016phog +--- +We introduce a new generative model for code called probabilistic higher order grammar (PHOG). PHOG generalizes probabilistic context free grammars (PCFGs) by allowing conditioning of a production rule beyond the parent non-terminal, thus capturing rich contexts relevant to programs. Even though PHOG is more powerful than a PCFG, it can be learned from data just as efficiently. We trained a PHOG model on a large JavaScript code corpus and show that it is more precise than existing models, while similarly fast. As a result, PHOG can immediately benefit existing programming tools based on probabilistic models of code. diff --git a/_publications/bruch2009learning.markdown b/_publications/bruch2009learning.markdown new file mode 100644 index 00000000..105a75c0 --- /dev/null +++ b/_publications/bruch2009learning.markdown @@ -0,0 +1,10 @@ +--- +layout: publication +title: "Learning from Examples to Improve Code Completion Systems" +authors: M. Bruch, M. Monperrus, and M. Mezini +conference: ESEC/FSE +year: 2009 +bibkey: bruch2009learning +--- +The suggestions made by current IDE’s code completion features are based exclusively on static type system of the programming language. As a result, often proposals are made which are irrelevant for a particular working context. Also, these suggestions are ordered alphabetically rather than by their relevance in a particular context. In this paper, we present intelligent code completion systems that learn from existing code repositories. We have implemented three such systems, each using the information contained in +repositories in a different way. We perform a large-scale quantitative evaluation of these systems, integrate the best performing one into Eclipse, and evaluate the latter also by a user study. Our experiments give evidence that intelligent code completion systems which learn from examples significantly outperform mainstream code completion systems in terms of the relevance of their suggestions and thus have the potential to enhance developers’ productivity. diff --git a/_publications/campbell2014syntax.markdown b/_publications/campbell2014syntax.markdown new file mode 100644 index 00000000..694ba186 --- /dev/null +++ b/_publications/campbell2014syntax.markdown @@ -0,0 +1,10 @@ +--- +layout: publication +title: "Syntax Errors Just Aren’t Natural: Improving Error Reporting with Language Models" +authors: J. C. Campbell, A. Hindle, J. N. Amaral +conference: MSR +year: 2014 +bibkey: campbell2014syntax +--- +A frustrating aspect of software development is that compiler error messages often fail to locate the actual cause of a syntax error. An errant semicolon or brace can result in +many errors reported throughout the file. We seek to find the actual source of these syntax errors by relying on the consistency of software: valid source code is usually repetitive and unsurprising. We exploit this consistency by constructing a simple N-gram language model of lexed source code tokens. We implemented an automatic Java syntax-error locator using the corpus of the project itself and evaluated its performance on mutated source code from several projects. Our tool, trained on the past versions of a project, can effectively augment the syntax error locations produced by the native compiler. Thus we provide a methodology and tool that exploits the naturalness of software source code to detect syntax errors alongside the parser. diff --git a/_publications/cerulo2013hidden.markdown b/_publications/cerulo2013hidden.markdown new file mode 100644 index 00000000..3a021fbc --- /dev/null +++ b/_publications/cerulo2013hidden.markdown @@ -0,0 +1,15 @@ +--- +layout: publication +title: "A Hidden Markov Model to Detect Coded Information Islands in Free Text" +authors: L. Cerulo, M. Ceccarelli, M. Di Penta, G. Canfora +conference: SCAM +year: 2013 +bibkey: cerulo2013hidden +--- +Emails and issue reports capture useful knowledge about development practices, bug fixing, and change activities. Extracting such a content is challenging, due to the mix-up of +source code and natural language, unstructured text. + +In this paper we introduce an approach, based on Hidden Markov Models (HMMs), to extract coded information islands, such as source code, stack traces, and patches, from free text at a token level of granularity. We train a HMM for each category of information contained in the text, and adopt the Viterbi algorithm to recognize whether the sequence of tokens—e.g., words, language keywords, numbers, parentheses, punctuation marks, etc.—observed in a text switches among those HMMs. Although our implementation focuses on extracting source code from emails, the approach could be easily extended to include in principle any text-interleaved language. + +We evaluated our approach with respect to the state of art on a set of development emails and bug reports drawn from the software repositories of well known open source systems. Results indicate an accuracy between 82% and 99%, which is in line with existing approaches which, differently from ours, require the manual definition of regular expressions or parsers. + diff --git a/_publications/cerulo2015irish.markdown b/_publications/cerulo2015irish.markdown new file mode 100644 index 00000000..469c1e71 --- /dev/null +++ b/_publications/cerulo2015irish.markdown @@ -0,0 +1,14 @@ +--- +layout: publication +title: "Irish: A Hidden Markov Model to detect coded information islands in free text" +authors: L. Cerulo, M. Di Penta, A. Bacchelli, M, Ceccarelli, G. Canfora +conference: Science of Computer Programming +year: 2015 +bibkey: cerulo2015irish +--- +Developers’ communication, as contained in emails, issue trackers, and forums, is a precious source of information to support the development process. For example, it can +be used to capture knowledge about development practice or about a software project itself. Thus, extracting the content of developers’ communication can be useful to support +several software engineering tasks, such as program comprehension, source code analysis, and software analytics. However, automating the extraction process is challenging, due to the unstructured nature of free text, which mixes different coding languages (e.g., source code, stack dumps, and log traces) with natural language parts. + +We conduct an extensive evaluation of Irish (InfoRmation ISlands Hmm), an approach we proposed to extract islands of coded information from free text at token granularity, with respect to the state of art approaches based on island parsing or island parsing combined with machine learners. The evaluation considers a wide set of natural language documents (e.g., textbooks, forum discussions, and development emails) taken from different contexts and encompassing different coding languages. Results indicate an F-measure of Irish between 74% and 99%; this is in line with existing approaches which, differently from Irish, require specific expertise for the definition of regular expressions or grammars. + diff --git a/_publications/corley2015exploring.markdown b/_publications/corley2015exploring.markdown new file mode 100644 index 00000000..8a1030ce --- /dev/null +++ b/_publications/corley2015exploring.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Exploring the Use of Deep Learning for Feature Location" +authors: C.S. Corley, K. Damevski, N.A. Kraft +conference: +year: 2015 +bibkey: corley2015exploring +--- +Deep learning models are a class of neural networks. Relative to n-gram models, deep learning models can capture more complex statistical patterns based on smaller training corpora. In this paper we explore the use of a particular deep learning model, document vectors (DVs), for feature location. DVs seem well suited to use with source code, because they both capture the influence of context on each term in a corpus and map terms into a continuous semantic space that encodes semantic relationships such as synonymy. We present preliminary results that show that a feature location technique (FLT) based on DVs can outperform an analogous FLT based on latent Dirichlet allocation (LDA) and then suggest several directions for future work on the use of deep learning models to improve developer effectiveness in feature location. diff --git a/_publications/cummins2017end.markdown b/_publications/cummins2017end.markdown new file mode 100644 index 00000000..f88e516a --- /dev/null +++ b/_publications/cummins2017end.markdown @@ -0,0 +1,13 @@ +--- +layout: publication +title: "End-to-end Deep Learning of Optimization Heuristics" +authors: C. Cummins, P. Petoumenos, Z. Wang, H. Leather +conference: +year: 2017 +bibkey: cummins2017end +--- +Accurate automatic optimization heuristics are necessary for dealing with the complexity and diversity of modern hardware and software. Machine learning is a proven technique for learning such heuristics, but its success is bound by the quality of the features used. These features must be hand crafted by developers through a combination of expert domain knowledge and trial and error. This makes the quality of the final model directly dependent on the skill and available time of the system architect. + +Our work introduces a better way for building heuristics. We develop a deep neural network that learns heuristics over raw code, entirely without using code features. The neural network simultaneously constructs appropriate representations of the code and learns how best to optimize, removing the need for manual feature creation. Further, we show that our neural nets can transfer learning from one optimization problem to another, improving the accuracy of new models, without the help of human experts. + +We compare the effectiveness of our automatically generated heuristics against ones with features hand-picked by experts. We examine two challenging tasks: predicting optimal mapping for heterogeneous parallelism and GPU thread coarsening factors. In 89% of the cases, the quality of our fully automatic heuristics matches or surpasses that of state-of-the-art predictive models using hand-crafted features, providing on average 14% and 12% more performance with no human effort expended on designing features. diff --git a/base-taxonomy/generative.html b/base-taxonomy/generative.html index 82e8e9b2..00aef75a 100644 --- a/base-taxonomy/generative.html +++ b/base-taxonomy/generative.html @@ -5,7 +5,6 @@

Code-Generating Models

{% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %} -
NameInput Code RepresentationTargetIntermediate RepresentationApplication
{% for publication in publicationsList %}{% if publication.categories contains "generative" %} diff --git a/base-taxonomy/pattern.html b/base-taxonomy/pattern.html index 165e050c..fffd2bc5 100644 --- a/base-taxonomy/pattern.html +++ b/base-taxonomy/pattern.html @@ -11,7 +11,7 @@

Pattern Mining Models

{% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} - + diff --git a/base-taxonomy/representational.html b/base-taxonomy/representational.html index 5509d1d3..00bb7bcc 100644 --- a/base-taxonomy/representational.html +++ b/base-taxonomy/representational.html @@ -11,7 +11,7 @@

Representational Models

{% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} - + diff --git a/papers.html b/papers.html index 9d84a81d..eae208f7 100644 --- a/papers.html +++ b/papers.html @@ -3,7 +3,7 @@ title: Home --- -{% assign publicationsByYear = site.publications | group_by:"year" %} +{% assign publicationsByYear = site.publications | sort: "year" | group_by: "year" %} {% for year in publicationsByYear reversed %}

{{ year.name }}

    From c822e951b9ec8117c688cc93a5452e0761928513 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Tue, 12 Sep 2017 22:39:22 +0100 Subject: [PATCH 15/98] Added more pubs. --- _data/allamanistaxonomy.yml | 2 +- _publications/fowkes2016parameter.markdown | 10 ++++++ _publications/fowkes2017autofolding.markdown | 10 ++++++ _publications/franks2015cacheca.markdown | 9 +++++ _publications/gu2016deep.markdown | 13 +++++++ _publications/gulwani2014nlyze.markdown | 27 ++++++++++++++ _publications/hellendoorn2015will.markdown | 22 ++++++++++++ _publications/hellendoorn2017deep.markdown | 25 +++++++++++++ _publications/hindle2012naturalness.markdown | 36 +++++++++++++++++++ _publications/hsiao2014using.markdown | 29 +++++++++++++++ _publications/karaivanov2014phrase.markdown | 31 ++++++++++++++++ .../karpathy2015visualizing.markdown | 20 +++++++++++ _publications/koc2017learning.markdown | 28 +++++++++++++++ _publications/li2016gated.markdown | 18 ++++++++++ _publications/li2017software.markdown | 30 ++++++++++++++++ _publications/ling2016latent.markdown | 26 ++++++++++++++ _publications/liu2016towards.markdown | 20 +++++++++++ 17 files changed, 355 insertions(+), 1 deletion(-) create mode 100644 _publications/fowkes2016parameter.markdown create mode 100644 _publications/fowkes2017autofolding.markdown create mode 100644 _publications/franks2015cacheca.markdown create mode 100644 _publications/gu2016deep.markdown create mode 100644 _publications/gulwani2014nlyze.markdown create mode 100644 _publications/hellendoorn2015will.markdown create mode 100644 _publications/hellendoorn2017deep.markdown create mode 100644 _publications/hindle2012naturalness.markdown create mode 100644 _publications/hsiao2014using.markdown create mode 100644 _publications/karaivanov2014phrase.markdown create mode 100644 _publications/karpathy2015visualizing.markdown create mode 100644 _publications/koc2017learning.markdown create mode 100644 _publications/li2016gated.markdown create mode 100644 _publications/li2017software.markdown create mode 100644 _publications/ling2016latent.markdown create mode 100644 _publications/liu2016towards.markdown diff --git a/_data/allamanistaxonomy.yml b/_data/allamanistaxonomy.yml index e54a8f48..de6d6001 100644 --- a/_data/allamanistaxonomy.yml +++ b/_data/allamanistaxonomy.yml @@ -86,7 +86,7 @@ # Pattern Models - {bibtex: allamanis2016mining, categories: [pattern], representation: Abstracted AST , pattern_type: Graphical Model , application: Semantic Idiom Mining } -- {bibtex: fowkes2015parameter, categories: [pattern], representation: API Call Sequences , pattern_type: Graphical Model , application: API Mining } +- {bibtex: fowkes2016parameter, categories: [pattern], representation: API Call Sequences , pattern_type: Graphical Model , application: API Mining } - {bibtex: murali2017bayesian, categories: [pattern], representation: Sketch Synthesis , pattern_type: Graphical Model , application: Sketch Mining } - {bibtex: murali2017finding, categories: [pattern], representation: API Usage Errors , pattern_type: Graphical Model , application: Defect Prediction } - {bibtex: movshovitz2015kb, categories: [pattern], representation: Tokens , pattern_type: Graphical Model , application: Knowledge-Base Mining } diff --git a/_publications/fowkes2016parameter.markdown b/_publications/fowkes2016parameter.markdown new file mode 100644 index 00000000..38bdf7b1 --- /dev/null +++ b/_publications/fowkes2016parameter.markdown @@ -0,0 +1,10 @@ +--- +layout: publication +title: "Parameter-Free Probabilistic API Mining across GitHub" +authors: J. Fowkes, C. Sutton +conference: FSE +year: 2016 +bibkey: fowkes2016parameter +--- +Existing API mining algorithms can be difficult to use as they require expensive parameter tuning and the returned set of API calls can be large, highly redundant and difficult to understand. To address this, we present PAM (Probabilistic API Miner), a near parameter-free probabilistic algorithm for mining the most interesting API call patterns. We show that PAM significantly outperforms both MAPO and UPMiner, achieving 69% test-set precision, at retrieving relevant API call sequences from GitHub. Moreover, we focus on libraries for which the developers have explicitly provided code examples, yielding over 300,000 LOC of hand-written API example code from the 967 client projects in the data set. This evaluation suggests that the hand-written examples actually have limited coverage of real API usages. + diff --git a/_publications/fowkes2017autofolding.markdown b/_publications/fowkes2017autofolding.markdown new file mode 100644 index 00000000..0e7391d1 --- /dev/null +++ b/_publications/fowkes2017autofolding.markdown @@ -0,0 +1,10 @@ +--- +layout: publication +title: "Autofolding for Source Code Summarization" +authors: J. Fowkes, R. Ranca, M. Allamanis, M. Lapata, C. Sutton +conference: TSE +year: 2017 +bibkey: fowkes2017autofolding +--- +Developers spend much of their time reading and browsing source code, raising new opportunities for summarization methods. Indeed, modern code editors provide code folding, which allows one to selectively hide blocks of code. However this is impractical to use as folding decisions must be made manually or based on simple rules. We introduce the +autofolding problem, which is to automatically create a code summary by folding less informative code regions. We present a novel solution by formulating the problem as a sequence of AST folding decisions, leveraging a scoped topic model for code tokens. On an annotated set of popular open source projects, we show that our summarizer outperforms simpler baselines, yielding a 28% error reduction. Furthermore, we find through a case study that our summarizer is strongly preferred by experienced developers. More broadly, we hope this work will aid program comprehension by turning code folding into a usable and valuable tool. diff --git a/_publications/franks2015cacheca.markdown b/_publications/franks2015cacheca.markdown new file mode 100644 index 00000000..337ee332 --- /dev/null +++ b/_publications/franks2015cacheca.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "CACHECA: A Cache Language Model Based Code Suggestion Tool" +authors: C. Franks, Z. Tu, P. Devanbu, V. Hellendoorn +conference: ICSE +year: 2015 +bibkey: franks2015cacheca +--- +Nearly every Integrated Development Environment includes a form of code completion. The suggested completions ("suggestions") are typically based on information available at compile time, such as type signatures and variables in scope. A statistical approach, based on estimated models of code patterns in large code corpora, has been demonstrated to be effective at predicting tokens given a context. In this demo, we present CACHECA, an Eclipse plugin that combines the native suggestions with a statistical suggestion regime. We demonstrate that a combination of the two approaches more than doubles Eclipse’s suggestion accuracy. A video demonstration is available at [https://www.youtube.com/watch?v=3INk0N3JNtc](https://www.youtube.com/watch?v=3INk0N3JNtc). diff --git a/_publications/gu2016deep.markdown b/_publications/gu2016deep.markdown new file mode 100644 index 00000000..6bd16517 --- /dev/null +++ b/_publications/gu2016deep.markdown @@ -0,0 +1,13 @@ +--- +layout: publication +title: "Deep API Learning" +authors: X. Gu, H. Zhang, D. Zhang, S. Kim +conference: FSE +year: 2016 +bibkey: gu2016deep +--- +Developers often wonder how to implement a certain functionality (e.g., how to parse XML files) using APIs. Obtaining an API usage sequence based on an API-related natural language query is very helpful in this regard. Given a query, existing approaches utilize information retrieval models to search for matching API sequences. These approaches treat queries and APIs as bag-of-words (i.e., keyword matching or word-to-word alignment) and lack a deep understanding of the semantics of the query. + +We propose DeepAPI, a deep learning based approach to generate API usage sequences for a given natural language query. Instead of a bags-of-words assumption, it learns the +sequence of words in a query and the sequence of associated APIs. DeepAPI adapts a neural language model named RNN Encoder-Decoder. It encodes a word sequence (user query) into a fixed-length context vector, and generates an API sequence based on the context vector. We also augment the RNN Encoder-Decoder by considering the importance of individual APIs. We empirically evaluate our approach with more than 7 million annotated code snippets collected from GitHub. The results show that our approach generates largely accurate API sequences and outperforms the related approaches. + diff --git a/_publications/gulwani2014nlyze.markdown b/_publications/gulwani2014nlyze.markdown new file mode 100644 index 00000000..f486a0eb --- /dev/null +++ b/_publications/gulwani2014nlyze.markdown @@ -0,0 +1,27 @@ +--- +layout: publication +title: "NLyze: Interactive Programming by Natural Language for SpreadSheet Data Analysis and Manipulation" +authors: S. Gulwani, M. Marron +conference: SIGMOD +year: 2014 +bibkey: gulwani2014nlyze +--- +Millions of computer end users need to perform tasks over tabular spreadsheet data, yet lack the programming knowledge to do such tasks automatically. This paper describes +the design and implementation of a robust natural language +based interface to spreadsheet programming. Our methodology involves designing a typed domain-specific language +(DSL) that supports an expressive algebra of map, filter, reduce, join, and formatting capabilities at a level of abstraction appropriate for non-expert users. The key algorithmic +component of our methodology is a translation algorithm +for converting a natural language specification in the context of a given spreadsheet to a ranked set of likely programs +in the DSL. The translation algorithm leverages the spreadsheet spatial and temporal context to assign interpretations +to specifications with implicit references, and is thus robust +to a variety of ways in which end users can express the same +task. The translation algorithm builds over ideas from keyword programming and semantic parsing to achieve both +high precision and high recall. We implemented the system +as an Excel add-in called NLyze that supports a rich user +interaction model including annotating the user’s natural +language specification and explaining the synthesized DSL +programs by paraphrasing them into structured English. We +collected a total of 3570 English descriptions for 40 spreadsheet tasks and our system was able to generate the intended +interpretation as the top candidate for 94% (97% for the top +3) of those instances. + diff --git a/_publications/hellendoorn2015will.markdown b/_publications/hellendoorn2015will.markdown new file mode 100644 index 00000000..f2a2c6e6 --- /dev/null +++ b/_publications/hellendoorn2015will.markdown @@ -0,0 +1,22 @@ +--- +layout: publication +title: "Will they like this? Evaluating Code Contributions With Language Models" +authors: V.J. Hellendoorn, P. Devanbu, A. Bacchelli +conference: MSR +year: 2015 +bibkey: hellendoorn2015will +--- +Popular open-source software projects receive and +review contributions from a diverse array of developers, many +of whom have little to no prior involvement with the project. A +recent survey reported that reviewers consider conformance to +the project’s code style to be one of the top priorities when evaluating code contributions on Github. We propose to quantitatively +evaluate the existence and effects of this phenomenon. To this aim +we use language models, which were shown to accurately capture +stylistic aspects of code. We find that rejected changesets do +contain code significantly less similar to the project than accepted +ones; furthermore, the less similar changesets are more likely +to be subject to thorough review. Armed with these results we +further investigate whether new contributors learn to conform to +the project style and find that experience is positively correlated +with conformance to the project’s code style. diff --git a/_publications/hellendoorn2017deep.markdown b/_publications/hellendoorn2017deep.markdown new file mode 100644 index 00000000..42346ea9 --- /dev/null +++ b/_publications/hellendoorn2017deep.markdown @@ -0,0 +1,25 @@ +--- +layout: publication +title: "Are Deep Neural Networks the Best Choice for Modeling Source Code?" +authors: V. J. Hellendoorn, P. Devanbu +conference: FSE +year: 2017 +bibkey: hellendoorn2017deep +--- +Current statistical language modeling techniques, including deep-learning based models, have proven to be quite effective for source +code. We argue here that the special properties of source code can +be exploited for further improvements. In this work, we enhance +established language modeling approaches to handle the special +challenges of modeling source code, such as: frequent changes, +larger, changing vocabularies, deeply nested scopes, etc. We present +a fast, nested language modeling toolkit specifically designed for +software, with the ability to add & remove text, and mix & swap out +many models. Specifically, we improve upon prior cache-modeling +work and present a model with a much more expansive, multi-level +notion of locality that we show to be well-suited for modeling +software. We present results on varying corpora in comparison +with traditional N -gram, as well as RNN, and LSTM deep-learning +language models, and release all our source code for public use. +Our evaluations suggest that carefully adapting N-gram models for +source code can yield performance that surpasses even RNN and +LSTM based deep-learning models. diff --git a/_publications/hindle2012naturalness.markdown b/_publications/hindle2012naturalness.markdown new file mode 100644 index 00000000..3d85b3f6 --- /dev/null +++ b/_publications/hindle2012naturalness.markdown @@ -0,0 +1,36 @@ +--- +layout: publication +title: "On the Naturalness of Software" +authors: A. Hindle, E. T. Barr, Z. Su, M. Gabel, P. Devanbu +conference: ICSE +year: 2012 +bibkey: hindle2012naturalness +--- +Natural languages like English are rich, complex, +and powerful. The highly creative and graceful use of languages +like English and Tamil, by masters like Shakespeare and +Avvaiyar, can certainly delight and inspire. But in practice, +given cognitive constraints and the exigencies of daily life, most +human utterances are far simpler and much more repetitive +and predictable. In fact, these utterances can be very usefully +modeled using modern statistical methods. This fact has led +to the phenomenal success of statistical approaches to speech +recognition, natural language translation, question-answering, +and text mining and comprehension. + +We begin with the conjecture that most software is also +natural, in the sense that it is created by humans at work, +with all the attendant constraints and limitations—and thus, +like natural language, it is also likely to be repetitive and +predictable. We then proceed to ask whether a) code can +be usefully modeled by statistical language models and b) +such models can be leveraged to support software engineers. +Using the widely adopted n-gram model, we provide empirical +evidence supportive of a positive answer to both these questions. +We show that code is also very repetitive, and in fact even more +so than natural languages. As an example use of the model, +we have developed a simple code completion engine for Java +that, despite its simplicity, already improves Eclipse’s built-in +completion capability. We conclude the paper by laying out a +vision for future research in this area. + diff --git a/_publications/hsiao2014using.markdown b/_publications/hsiao2014using.markdown new file mode 100644 index 00000000..2c692ab7 --- /dev/null +++ b/_publications/hsiao2014using.markdown @@ -0,0 +1,29 @@ +--- +layout: publication +title: "Using Web Corpus Statistics for Program Analysis" +authors: C. Hsiao, M. Cafarella, S. Narayanasamy +conference: OOPSLA +year: 2014 +bibkey: hsiao2014using +--- +Several program analysis tools—such as plagiarism detection and bug finding—rely on knowing a piece of code’s +relative semantic importance. For example, a plagiarism detector should not bother reporting two programs that have +an identical simple loop counter test, but should report programs that share more distinctive code. Traditional program +analysis techniques (e.g., finding data and control dependencies) are useful, but do not say how surprising or common +a line of code is. Natural language processing researchers +have encountered a similar problem and addressed it using +an n-gram model of text frequency, derived from statistics +computed over text corpora. + +We propose and compute an n-gram model for programming languages, computed over a corpus of 2.8 million +JavaScript programs we downloaded from the Web. In contrast to previous techniques, we describe a code n-gram as +a subgraph of the program dependence graph that contains +all nodes and edges reachable in n steps from the statement. +We can count n-grams in a program and count the frequency +of n-grams in the corpus, enabling us to compute tf-idf-style +measures that capture the differing importance of different +lines of code. We demonstrate the power of this approach by +implementing a plagiarism detector with accuracy that beats +previous techniques, and a bug-finding tool that discovered +over a dozen previously unknown bugs in a collection of real +deployed programs. diff --git a/_publications/karaivanov2014phrase.markdown b/_publications/karaivanov2014phrase.markdown new file mode 100644 index 00000000..4e4b8f50 --- /dev/null +++ b/_publications/karaivanov2014phrase.markdown @@ -0,0 +1,31 @@ +--- +layout: publication +title: "Phrase-Based Statistical Translation of Programming Languages" +authors: S. Karaivanov, V. Raychev, M. Vechev +conference: Onward +year: 2014 +bibkey: karaivanov2014phrase +--- +Phrase-based statistical machine translation approaches have been +highly successful in translating between natural languages and are +heavily used by commercial systems (e.g. Google Translate). + +The main objective of this work is to investigate the applicability of +these approaches for translating between programming languages. +Towards that, we investigated several variants of the phrase-based +translation approach: i) a direct application of the approach to +programming languages, ii) a novel modification of the approach +to incorporate the grammatical structure of the target programming +language (so to avoid generating target programs which do not +parse), and iii) a combination of ii) with custom rules added to +improve the quality of the translation. + +To experiment with the above systems, we investigated machine +translation from C# to Java. For the training, which takes about +60 hours, we used a parallel corpus of 20, 499 C#-to-Java method +translations. We then evaluated each of the three systems above by +translating 1,000 C# methods. Our experimental results indicate +that with the most advanced system, about 60% of the translated +methods compile (the top ranked) and out of a random sample of 50 +correctly compiled methods, 68% (34 methods) were semantically +equivalent to the reference solution. diff --git a/_publications/karpathy2015visualizing.markdown b/_publications/karpathy2015visualizing.markdown new file mode 100644 index 00000000..0221c3bb --- /dev/null +++ b/_publications/karpathy2015visualizing.markdown @@ -0,0 +1,20 @@ +--- +layout: publication +title: "Visualizing and Understanding Recurrent Networks" +authors: A. Karpathy, J. Johnson, L. Fei-Fei +conference: "arXiv preprint arXiv:1506.02078" +year: 2015 +bibkey: karpathy2015visualizing +--- +Recurrent Neural Networks (RNNs), and specifically a variant with Long Short-Term Memory (LSTM), are enjoying renewed interest as a result of successful +applications in a wide range of machine learning problems that involve sequential +data. However, while LSTMs provide exceptional results in practice, the source +of their performance and their limitations remain rather poorly understood. Using character-level language models as an interpretable testbed, we aim to bridge +this gap by providing an analysis of their representations, predictions and error +types. In particular, our experiments reveal the existence of interpretable cells that +keep track of long-range dependencies such as line lengths, quotes and brackets. +Moreover, our comparative analysis with finite horizon n-gram models traces the +source of the LSTM improvements to long-range structural dependencies. Finally, +we provide analysis of the remaining errors and suggests areas for further study. + + diff --git a/_publications/koc2017learning.markdown b/_publications/koc2017learning.markdown new file mode 100644 index 00000000..6d5f382c --- /dev/null +++ b/_publications/koc2017learning.markdown @@ -0,0 +1,28 @@ +--- +layout: publication +title: "Learning a Classifier for False Positive Error Reports Emitted by Static Code Analysis Tools" +authors: U. Koc, P. Saadatpanah, J. S. Foster, A. A. Porter +conference: MAPL +year: 2017 +bibkey: koc2017learning +--- +The large scale and high complexity of modern software systems +make perfectly precise static code analysis (SCA) infeasible. Therefore SCA tools often over-approximate, so not to miss any real +problems. This, however, comes at the expense of raising false +alarms, which, in practice, reduces the usability of these tools. + +To partially address this problem, we propose a novel learning +process whose goal is to discover program structures that cause +a given SCA tool to emit false error reports, and then to use this +information to predict whether a new error report is likely to be a +false positive as well. To do this, we first preprocess code to isolate +the locations that are related to the error report. Then, we apply +machine learning techniques to the preprocessed code to discover +correlations and to learn a classifier. + +We evaluated this approach in an initial case study of a widely-used SCA tool for Java. Our results showed that for our dataset +we could accurately classify a large majority of false positive error +reports. Moreover, we identified some common coding patterns that +led to false positive errors. We believe that SCA developers may be +able to redesign their methods to address these patterns and reduce +false positive error reports. diff --git a/_publications/li2016gated.markdown b/_publications/li2016gated.markdown new file mode 100644 index 00000000..d2eb1263 --- /dev/null +++ b/_publications/li2016gated.markdown @@ -0,0 +1,18 @@ +--- +layout: publication +title: "Gated Graph Sequence Neural Networks" +authors: Y. Li, R. Zemel, M. Brockschmidt, D. Tarlow +conference: ICLR +year: 2016 +bibkey: li2016gated +--- +Graph-structured data appears frequently in domains including chemistry, natural +language semantics, social networks, and knowledge bases. In this work, we study +feature learning techniques for graph-structured inputs. Our starting point is previous work on Graph Neural Networks (Scarselli et al., 2009), which we modify +to use gated recurrent units and modern optimization techniques and then extend +to output sequences. The result is a flexible and broadly useful class of neural network models that has favorable inductive biases relative to purely sequence-based +models (e.g., LSTMs) when the problem is graph-structured. We demonstrate the +capabilities on some simple AI (bAbI) and graph algorithm learning tasks. We +then show it achieves state-of-the-art performance on a problem from program +verification, in which subgraphs need to be described as abstract data structures. + diff --git a/_publications/li2017software.markdown b/_publications/li2017software.markdown new file mode 100644 index 00000000..e7aecfb8 --- /dev/null +++ b/_publications/li2017software.markdown @@ -0,0 +1,30 @@ +--- +layout: publication +title: "Software Defect Prediction via Convolutional Neural Network" +authors: J. Li, P. He, J. Zhu, and M. R. Lyu +conference: QRS +year: 2017 +bibkey: li2017software +--- +To improve software reliability, software defect prediction is utilized to assist developers in finding potential bugs +and allocating their testing efforts. Traditional defect prediction +studies mainly focus on designing hand-crafted features, which +are input into machine learning classifiers to identify defective +code. However, these hand-crafted features often fail to capture +the semantic and structural information of programs. Such +information is important in modeling program functionality and +can lead to more accurate defect prediction. +In this paper, we propose a framework called Defect Prediction +via Convolutional Neural Network (DP-CNN), which leverages +deep learning for effective feature generation. Specifically, based +on the programs’ Abstract Syntax Trees (ASTs), we first extract +token vectors, which are then encoded as numerical vectors +via mapping and word embedding. We feed the numerical +vectors into Convolutional Neural Network to automatically +learn semantic and structural features of programs. After that, +we combine the learned features with traditional hand-crafted +features, for accurate software defect prediction. We evaluate our +method on seven open source projects in terms of F-measure in +defect prediction. The experimental results show that in average, +DP-CNN improves the state-of-the-art method by 12%. + diff --git a/_publications/ling2016latent.markdown b/_publications/ling2016latent.markdown new file mode 100644 index 00000000..f467f94c --- /dev/null +++ b/_publications/ling2016latent.markdown @@ -0,0 +1,26 @@ +--- +layout: publication +title: "Latent Predictor Networks for Code Generation" +authors: W. Ling, E. Grefenstette, K. M. Hermann, T. Kocisky, A. Senior, F. Wang, P. Blunsom +conference: ACL +year: 2016 +bibkey: ling2016latent +--- +Many language generation tasks require +the production of text conditioned on both +structured and unstructured inputs. +We present a novel neural network architecture which generates an output sequence +conditioned on an arbitrary number of input functions. +Crucially, our approach +allows both the choice of conditioning +context and the granularity of generation, +for example characters or tokens, to be +marginalised, thus permitting scalable and +effective training. Using this framework, +we address the problem of generating programming code from a mixed natural language and structured specification. +We create two new data sets for this paradigm +derived from the collectible trading card +games Magic the Gathering and Hearthstone. On these, and a third preexisting +corpus, we demonstrate that marginalising multiple predictors allows our model +to outperform strong benchmarks. + diff --git a/_publications/liu2016towards.markdown b/_publications/liu2016towards.markdown new file mode 100644 index 00000000..1754b4cf --- /dev/null +++ b/_publications/liu2016towards.markdown @@ -0,0 +1,20 @@ +--- +layout: publication +title: "Towards Better Program Obfuscation: Optimization via Language Models" +authors: H. Liu +conference: ICSE +year: 2016 +bibkey: liu2016towards +--- +As a common practice in software development, program +obfuscation aims at deterring reverse engineering and malicious attacks on released source or binary code. Owning ample obfuscation techniques, we have relatively little +knowledge on how to most effectively use them. The biggest +challenge lies in identifying the most useful combination of +these techniques. We propose a unified framework to automatically generate and optimize obfuscation based on an +obscurity language model and a Monte Carlo Markov Chain +(MCMC) based search algorithm. We further instantiate it +for JavaScript programs and developed the Closure tool. +Compared to the well-known Google Closure Compiler, Closure outperforms its default setting by 26%. For programs +which have already been well obfuscated, Closure can still +outperform by 22%. + From 73394b3da03d70d111ed5d71ad74453adb25afb2 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Tue, 12 Sep 2017 22:41:44 +0100 Subject: [PATCH 16/98] Fix key --- _data/allamanistaxonomy.yml | 78 ++++++++++++++++++------------------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/_data/allamanistaxonomy.yml b/_data/allamanistaxonomy.yml index de6d6001..5297bbcf 100644 --- a/_data/allamanistaxonomy.yml +++ b/_data/allamanistaxonomy.yml @@ -4,7 +4,7 @@ - {bibkey: maddison2014structured, categories: [generative, representational], type: Language Model, representation: Syntax with scope , input_rep: LM AST Context, modeled_target: Language Model, intermediate_rep: Distributed, model: NN , application: --- } - {bibkey: rabinovich2017abstract, categories: [generative, representational], type: Multimodal, representation: Syntax , input_rep: LM AST context, modeled_target: LM (Syntax), intermediate_rep: Distributed, model: NN (LSTM-based), application: Code Synthesis} - {bibkey: white2015toward, categories: [generative, representational], type: Language Model, representation: Token , input_rep: Tokens, modeled_target: Language Model, model: NN (RNN) , intermediate_rep: Distributed, application: ---} -- {bibtex: white2016deep, categories: [representational, pattern], representation: Token + Syntax , pattern_type: Distributed, input_rep: Token + AST, intermediate_rep: Distributed, application: Clone Detection } +- {bibkey: white2016deep, categories: [representational, pattern], representation: Token + Syntax , pattern_type: Distributed, input_rep: Token + AST, intermediate_rep: Distributed, application: Clone Detection } # Generative Models - {bibkey: aggarwal2015using, categories: [generative], type: Transducer, representation: Token , model: Phrase , application: Migration} @@ -53,43 +53,43 @@ - {bibkey: yin2017syntactic, categories: [generative], type: Multimodal, representation: Syntax , model: NN (Seq2seq) , application: Synthesis} # Representational Models -- {bibtex: allamanis2015suggesting, categories: [representational], input_rep: Token Context , modeled_target: Identifier Name , intermediate_rep: Distributed , application: Naming } -- {bibtex: allamanis2016convolutional, categories: [representational], input_rep: Tokens , modeled_target: Method Name , intermediate_rep: Distributed , application: Naming } -- {bibtex: allamanis2017smartpaste, categories: [representational], input_rep: Data Flow , modeled_target: Variable Allocation , intermediate_rep: Distributed , application: Contextualization } -- {bibtex: bichsel2016statistical, categories: [representational], input_rep: Dependency Net , modeled_target: Identifier Name , intermediate_rep: CRF (GM) , application: Deobfuscation } -- {bibtex: bruch2009learning, categories: [representational], input_rep: Partial Object Use , modeled_target: Invoked Method , intermediate_rep: Localized , application: Code Completion } -- {bibtex: chae2016automatically, categories: [representational], input_rep: Data Flow Graph , modeled_target: Static Analysis , intermediate_rep: Localized , application: Program Analysis } -- {bibtex: corley2015exploring, categories: [representational], input_rep: Tokens , modeled_target: Feature Location , intermediate_rep: Distributed , application: Feature Location } -- {bibtex: cummins2017end, categories: [representational], input_rep: Tokens , modeled_target: Optimization Flags , intermediate_rep: Distributed , application: Optimization Heuristics } -- {bibtex: green2017learning, categories: [representational], input_rep: Statements, modeled_target: Alignment , intermediate_rep: Distributed , application: Decompiling } -- {bibtex: gu2016deep, categories: [representational], input_rep: Natural Language , modeled_target: API Calls , intermediate_rep: Distributed , application: API Search } -- {bibtex: guo2017semantically, categories: [representational], input_rep: Tokens , modeled_target: Traceability link , intermediate_rep: Distributed , application: Traceability } -- {bibtex: gupta2016deepfix, categories: [representational], input_rep: Tokens , modeled_target: Code Fix , intermediate_rep: Distributed , application: Code Fixing } -- {bibtex: hu2017codesum, categories: [representational], input_rep: Linearized AST , modeled_target: Natural Language , intermediate_rep: Distributed , application: Summarization } -- {bibtex: iyer2016summarizing, categories: [representational], input_rep: Tokens , modeled_target: Natural Language , intermediate_rep: Distributed , application: Summarization } -- {bibtex: jiang2017automatically, categories: [representational], input_rep: Tokens (Diff) , modeled_target: Natural Language , intermediate_rep: Distributed , application: Commit Message } -- {bibtex: koc2017learning, categories: [representational], input_rep: Bytecode , modeled_target: False Positives , intermediate_rep: Distributed , application: Program Analysis } -- {bibtex: kremenek2007factor, categories: [representational], input_rep: Partial PDG , modeled_target: Ownership , intermediate_rep: Factor (GM) , application: Pointer Ownership } -- {bibtex: loyola2017neural, categories: [representational], input_rep: Tokens (Diff) , modeled_target: Natural Language , intermediate_rep: Distributed , application: Explain code changes } -- {bibtex: li2015gated, categories: [representational], input_rep: Memory Heap , modeled_target: Separation Logic , intermediate_rep: Distributed , application: Verification } -- {bibtex: mangal2015user, categories: [representational], input_rep: Logic + Feedback , modeled_target: Prob. Analysis , intermediate_rep: MaxSAT , application: Program Analysis } -- {bibtex: movshovitz2013natural, categories: [representational], input_rep: Tokens , modeled_target: Code Comments , intermediate_rep: Directed GM , application: Comment Prediction } -- {bibtex: mou2016convolutional, categories: [representational], input_rep: Syntax , modeled_target: Classification , intermediate_rep: Distributed , application: Task Classification } -- {bibtex: nguyen2016mapping, categories: [representational], input_rep: API Calls , modeled_target: API Calls , intermediate_rep: Distributed , application: Migration } -- {bibtex: omar2013structured, categories: [representational], input_rep: Syntactic Context , modeled_target: Expressions , intermediate_rep: Directed GM , application: Code Completion } -- {bibtex: oh2015learning, categories: [representational], input_rep: Features , modeled_target: Analysis Params , intermediate_rep: Static Analysis , application: Program Analysis } -- {bibtex: piech2015learning, categories: [representational], input_rep: Syntax + State , modeled_target: Student Feedback , intermediate_rep: Distributed , application: Student Feedback } -- {bibtex: proksch2015intelligent, categories: [representational], input_rep: Inc. Object Usage , modeled_target: Object Usage , intermediate_rep: Directed GM , application: Code Completion } -- {bibtex: raychev2015predicting, categories: [representational], input_rep: Dependency Net , modeled_target: Types + Names , intermediate_rep: CRF (GM) , application: Types + Names } -- {bibtex: wang2016bugram, categories: [representational], input_rep: Tokens , modeled_target: Defects , intermediate_rep: LM (\ngram) , application: Bug Detection } -- {bibtex: zaremba2014learning, categories: [representational], input_rep: Characters , modeled_target: Execution Trace , intermediate_rep: Distributed , application: --- } +- {bibkey: allamanis2015suggesting, categories: [representational], input_rep: Token Context , modeled_target: Identifier Name , intermediate_rep: Distributed , application: Naming } +- {bibkey: allamanis2016convolutional, categories: [representational], input_rep: Tokens , modeled_target: Method Name , intermediate_rep: Distributed , application: Naming } +- {bibkey: allamanis2017smartpaste, categories: [representational], input_rep: Data Flow , modeled_target: Variable Allocation , intermediate_rep: Distributed , application: Contextualization } +- {bibkey: bichsel2016statistical, categories: [representational], input_rep: Dependency Net , modeled_target: Identifier Name , intermediate_rep: CRF (GM) , application: Deobfuscation } +- {bibkey: bruch2009learning, categories: [representational], input_rep: Partial Object Use , modeled_target: Invoked Method , intermediate_rep: Localized , application: Code Completion } +- {bibkey: chae2016automatically, categories: [representational], input_rep: Data Flow Graph , modeled_target: Static Analysis , intermediate_rep: Localized , application: Program Analysis } +- {bibkey: corley2015exploring, categories: [representational], input_rep: Tokens , modeled_target: Feature Location , intermediate_rep: Distributed , application: Feature Location } +- {bibkey: cummins2017end, categories: [representational], input_rep: Tokens , modeled_target: Optimization Flags , intermediate_rep: Distributed , application: Optimization Heuristics } +- {bibkey: green2017learning, categories: [representational], input_rep: Statements, modeled_target: Alignment , intermediate_rep: Distributed , application: Decompiling } +- {bibkey: gu2016deep, categories: [representational], input_rep: Natural Language , modeled_target: API Calls , intermediate_rep: Distributed , application: API Search } +- {bibkey: guo2017semantically, categories: [representational], input_rep: Tokens , modeled_target: Traceability link , intermediate_rep: Distributed , application: Traceability } +- {bibkey: gupta2016deepfix, categories: [representational], input_rep: Tokens , modeled_target: Code Fix , intermediate_rep: Distributed , application: Code Fixing } +- {bibkey: hu2017codesum, categories: [representational], input_rep: Linearized AST , modeled_target: Natural Language , intermediate_rep: Distributed , application: Summarization } +- {bibkey: iyer2016summarizing, categories: [representational], input_rep: Tokens , modeled_target: Natural Language , intermediate_rep: Distributed , application: Summarization } +- {bibkey: jiang2017automatically, categories: [representational], input_rep: Tokens (Diff) , modeled_target: Natural Language , intermediate_rep: Distributed , application: Commit Message } +- {bibkey: koc2017learning, categories: [representational], input_rep: Bytecode , modeled_target: False Positives , intermediate_rep: Distributed , application: Program Analysis } +- {bibkey: kremenek2007factor, categories: [representational], input_rep: Partial PDG , modeled_target: Ownership , intermediate_rep: Factor (GM) , application: Pointer Ownership } +- {bibkey: loyola2017neural, categories: [representational], input_rep: Tokens (Diff) , modeled_target: Natural Language , intermediate_rep: Distributed , application: Explain code changes } +- {bibkey: li2015gated, categories: [representational], input_rep: Memory Heap , modeled_target: Separation Logic , intermediate_rep: Distributed , application: Verification } +- {bibkey: mangal2015user, categories: [representational], input_rep: Logic + Feedback , modeled_target: Prob. Analysis , intermediate_rep: MaxSAT , application: Program Analysis } +- {bibkey: movshovitz2013natural, categories: [representational], input_rep: Tokens , modeled_target: Code Comments , intermediate_rep: Directed GM , application: Comment Prediction } +- {bibkey: mou2016convolutional, categories: [representational], input_rep: Syntax , modeled_target: Classification , intermediate_rep: Distributed , application: Task Classification } +- {bibkey: nguyen2016mapping, categories: [representational], input_rep: API Calls , modeled_target: API Calls , intermediate_rep: Distributed , application: Migration } +- {bibkey: omar2013structured, categories: [representational], input_rep: Syntactic Context , modeled_target: Expressions , intermediate_rep: Directed GM , application: Code Completion } +- {bibkey: oh2015learning, categories: [representational], input_rep: Features , modeled_target: Analysis Params , intermediate_rep: Static Analysis , application: Program Analysis } +- {bibkey: piech2015learning, categories: [representational], input_rep: Syntax + State , modeled_target: Student Feedback , intermediate_rep: Distributed , application: Student Feedback } +- {bibkey: proksch2015intelligent, categories: [representational], input_rep: Inc. Object Usage , modeled_target: Object Usage , intermediate_rep: Directed GM , application: Code Completion } +- {bibkey: raychev2015predicting, categories: [representational], input_rep: Dependency Net , modeled_target: Types + Names , intermediate_rep: CRF (GM) , application: Types + Names } +- {bibkey: wang2016bugram, categories: [representational], input_rep: Tokens , modeled_target: Defects , intermediate_rep: LM (\ngram) , application: Bug Detection } +- {bibkey: zaremba2014learning, categories: [representational], input_rep: Characters , modeled_target: Execution Trace , intermediate_rep: Distributed , application: --- } # Pattern Models -- {bibtex: allamanis2016mining, categories: [pattern], representation: Abstracted AST , pattern_type: Graphical Model , application: Semantic Idiom Mining } -- {bibtex: fowkes2016parameter, categories: [pattern], representation: API Call Sequences , pattern_type: Graphical Model , application: API Mining } -- {bibtex: murali2017bayesian, categories: [pattern], representation: Sketch Synthesis , pattern_type: Graphical Model , application: Sketch Mining } -- {bibtex: murali2017finding, categories: [pattern], representation: API Usage Errors , pattern_type: Graphical Model , application: Defect Prediction } -- {bibtex: movshovitz2015kb, categories: [pattern], representation: Tokens , pattern_type: Graphical Model , application: Knowledge-Base Mining } -- {bibtex: nguyen2017exploring, categories: [pattern], representation: API Usage , pattern_type: Distributed , application: API Mining } -- {bibtex: fowkes2017autofolding, categories: [pattern], representation: Tokens , pattern_type: Graphical Model , application: Code Summarization } -- {bibtex: wang2016automatically, categories: [pattern], representation: Serialized ASTs , pattern_type: Distributed , application: Defect Prediction } +- {bibkey: allamanis2016mining, categories: [pattern], representation: Abstracted AST , pattern_type: Graphical Model , application: Semantic Idiom Mining } +- {bibkey: fowkes2016parameter, categories: [pattern], representation: API Call Sequences , pattern_type: Graphical Model , application: API Mining } +- {bibkey: murali2017bayesian, categories: [pattern], representation: Sketch Synthesis , pattern_type: Graphical Model , application: Sketch Mining } +- {bibkey: murali2017finding, categories: [pattern], representation: API Usage Errors , pattern_type: Graphical Model , application: Defect Prediction } +- {bibkey: movshovitz2015kb, categories: [pattern], representation: Tokens , pattern_type: Graphical Model , application: Knowledge-Base Mining } +- {bibkey: nguyen2017exploring, categories: [pattern], representation: API Usage , pattern_type: Distributed , application: API Mining } +- {bibkey: fowkes2017autofolding, categories: [pattern], representation: Tokens , pattern_type: Graphical Model , application: Code Summarization } +- {bibkey: wang2016automatically, categories: [pattern], representation: Serialized ASTs , pattern_type: Distributed , application: Defect Prediction } From 7d313b9a699da984eec68699140f421476cb3183 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Wed, 13 Sep 2017 23:04:26 +0100 Subject: [PATCH 17/98] Added more publications. --- _publications/maddison2014structured.markdown | 23 +++++++++++++ _publications/mangal2015user.markdown | 23 +++++++++++++ _publications/mou2014building.markdown | 29 +++++++++++++++++ _publications/mou2015convolutional.markdown | 20 ++++++++++++ _publications/movshovitz2013natural.markdown | 24 ++++++++++++++ _publications/movshovitz2015kblda.markdown | 23 +++++++++++++ _publications/nguyen2013lexical.markdown | 23 +++++++++++++ _publications/nguyen2013statistical.markdown | 18 +++++++++++ _publications/nguyen2013study.markdown | 25 +++++++++++++++ _publications/nguyen2014statistical.markdown | 23 +++++++++++++ _publications/nguyen2015divide.markdown | 28 ++++++++++++++++ _publications/nguyen2015graph.markdown | 25 +++++++++++++++ _publications/nguyen2015learning.markdown | 25 +++++++++++++++ _publications/nguyen2016mapping.markdown | 9 ++++++ _publications/nguyen2017exploring.markdown | 32 +++++++++++++++++++ _publications/oda2015learning.markdown | 24 ++++++++++++++ _publications/oh2015learning.markdown | 29 +++++++++++++++++ _publications/omar2013structured.markdown | 18 +++++++++++ 18 files changed, 421 insertions(+) create mode 100644 _publications/maddison2014structured.markdown create mode 100644 _publications/mangal2015user.markdown create mode 100644 _publications/mou2014building.markdown create mode 100644 _publications/mou2015convolutional.markdown create mode 100644 _publications/movshovitz2013natural.markdown create mode 100644 _publications/movshovitz2015kblda.markdown create mode 100644 _publications/nguyen2013lexical.markdown create mode 100644 _publications/nguyen2013statistical.markdown create mode 100644 _publications/nguyen2013study.markdown create mode 100644 _publications/nguyen2014statistical.markdown create mode 100644 _publications/nguyen2015divide.markdown create mode 100644 _publications/nguyen2015graph.markdown create mode 100644 _publications/nguyen2015learning.markdown create mode 100644 _publications/nguyen2016mapping.markdown create mode 100644 _publications/nguyen2017exploring.markdown create mode 100644 _publications/oda2015learning.markdown create mode 100644 _publications/oh2015learning.markdown create mode 100644 _publications/omar2013structured.markdown diff --git a/_publications/maddison2014structured.markdown b/_publications/maddison2014structured.markdown new file mode 100644 index 00000000..d4d9212d --- /dev/null +++ b/_publications/maddison2014structured.markdown @@ -0,0 +1,23 @@ +--- +layout: publication +title: "Structured Generative Models of Natural Source Code" +authors: C.J. Maddison, D. Tarlow +conference: ICML +year: 2014 +bibkey: maddison2014structured +--- +We study the problem of building generative +models of natural source code (NSC); that is, +source code written by humans and meant to +be understood by humans. Our primary con- +tribution is to describe new generative models +that are tailored to NSC. The models are based +on probabilistic context free grammars (PCFGs) +and neuro-probabilistic language models (Mnih +& Teh, 2012), which are extended to incorporate +additional source code-specific structure. These +models can be efficiently trained on a corpus +of source code and outperform a variety of less +structured baselines in terms of predictive log +likelihoods on held-out data. + diff --git a/_publications/mangal2015user.markdown b/_publications/mangal2015user.markdown new file mode 100644 index 00000000..51efdbf9 --- /dev/null +++ b/_publications/mangal2015user.markdown @@ -0,0 +1,23 @@ +--- +layout: publication +title: "A User-Guided Approach to Program Analysis" +authors: R. Mangal, X. Zhang, A. V. Nori, M. Naik +conference: FSE +year: 2015 +bibkey: mangal2015user +--- +Program analysis tools often produce undesirable output +due to various approximations. We present an approach +and a system Eugene that allows user feedback to guide +such approximations towards producing the desired output. +We formulate the problem of user-guided program analysis in terms of solving a combination of hard rules and soft +rules: hard rules capture soundness while soft rules capture +degrees of approximations and preferences of users. Our +technique solves the rules using an off-the-shelf solver in a +manner that is sound (satisfies all hard rules), optimal (maximally satisfies soft rules), and scales to real-world analy- +ses and programs. We evaluate Eugene on two different +analyses with labeled output on a suite of seven Java pro- +grams of size 131–198 KLOC. We also report upon a user +study involving nine users who employ Eugene to guide an +information-flow analysis on three Java micro-benchmarks. +In our experiments, Eugene significantly reduces misclassified reports upon providing limited amounts of feedback. diff --git a/_publications/mou2014building.markdown b/_publications/mou2014building.markdown new file mode 100644 index 00000000..a9b0bda8 --- /dev/null +++ b/_publications/mou2014building.markdown @@ -0,0 +1,29 @@ +--- +layout: publication +title: "Building Program Vector Representations for Deep Learning" +authors: L. Mou, G. Li, Y. Liu, H. Peng, Z. Jin, Y. Xu, L. Zhang +conference: International Conference on Knowledge Science, Engineering and Management +year: 2014 +bibkey: mou2014building +--- +Deep learning has made significant breakthroughs +in various fields of artificial intelligence. Advantages of deep +learning include the ability to capture highly complicated features, weak involvement of human engineering, etc. However, +it is still virtually impossible to use deep learning to analyze +programs since deep architectures cannot be trained effectively +with pure back propagation. In this pioneering paper, we propose +the “coding criterion” to build program vector representations, +which are the premise of deep learning for program analysis. Our +representation learning approach directly makes deep learning a +reality in this new field. We evaluate the learned vector representations both qualitatively and quantitatively. We conclude, based +on the experiments, the coding criterion is successful in building +program representations. To evaluate whether deep learning +is beneficial for program analysis, we feed the representations +to deep neural networks, and achieve higher accuracy in the +program classification task than “shallow” methods, such as +logistic regression and the support vector machine. This result +confirms the feasibility of deep learning to analyze programs. It +also gives primary evidence of its success in this new field. We +believe deep learning will become an outstanding technique for +program analysis in the near future. + diff --git a/_publications/mou2015convolutional.markdown b/_publications/mou2015convolutional.markdown new file mode 100644 index 00000000..410240f9 --- /dev/null +++ b/_publications/mou2015convolutional.markdown @@ -0,0 +1,20 @@ +--- +layout: publication +title: "Convolutional Neural Networks over Tree Structures for Programming Language Processing" +authors: L. Mou, G. Li, L. Zhang, T. Wang, Z. Jin +conference: AAAI +year: 2015 +bibkey: mou2015convolutional +--- +Programming language processing (similar to natural +language processing) is a hot research topic in the field +of software engineering; it has also aroused growing interest in the artificial intelligence community. However, +different from a natural language sentence, a program +contains rich, explicit, and complicated structural information. Hence, traditional NLP models may be inappropriate for programs. In this paper, we propose a novel +tree-based convolutional neural network (TBCNN) for +programming language processing, in which a convolution kernel is designed over programs’ abstract syntax trees to capture structural information. TBCNN is +a generic architecture for programming language processing; our experiments show its effectiveness in two +different program analysis tasks: classifying programs +according to functionality, and detecting code snippets +of certain patterns. TBCNN outperforms baseline methods, including several neural models for NLP. + diff --git a/_publications/movshovitz2013natural.markdown b/_publications/movshovitz2013natural.markdown new file mode 100644 index 00000000..b85e18a6 --- /dev/null +++ b/_publications/movshovitz2013natural.markdown @@ -0,0 +1,24 @@ +--- +layout: publication +title: "Natural Language Models for Predicting Programming Comments" +authors: D. Movshovitz-Attias, W.W. Cohen +conference: ACL +year: 2013 +bibkey: movshovitz2013natural +--- +Statistical language models have successfully been used to describe and analyze +natural language documents. Recent work +applying language models to programming languages is focused on the task +of predicting code, while mainly ignoring +the prediction of programmer comments. +In this work, we predict comments from +JAVA source files of open source projects, +using topic models and n-grams, and we +analyze the performance of the models +given varying amounts of background data +on the project being predicted. We evaluate models on their comment-completion +capability in a setting similar to codecompletion tools built into standard code +editors, and show that using a comment +completion tool can save up to 47% of the +comment typing. + diff --git a/_publications/movshovitz2015kblda.markdown b/_publications/movshovitz2015kblda.markdown new file mode 100644 index 00000000..789e7c89 --- /dev/null +++ b/_publications/movshovitz2015kblda.markdown @@ -0,0 +1,23 @@ +--- +layout: publication +title: "KB-LDA: Jointly Learning a Knowledge Base of Hierarchy, Relations, and Facts" +authors: D. Movshovitz-Attias, W. W. Cohen +conference: ACL +year: 2015 +bibkey: movshovitz2015kblda +--- +Many existing knowledge bases (KBs), including Freebase, Yago, and NELL, rely +on a fixed ontology, given as an input +to the system, which defines the data to +be cataloged in the KB, i.e., a hierarchy of categories and relations between +them. The system then extracts facts that +match the predefined ontology. We propose an unsupervised model that jointly +learns a latent ontological structure of an +input corpus, and identifies facts from the +corpus that match the learned structure. +Our approach combines mixed membership stochastic block models and topic +models to infer a structure by jointly modeling text, a latent concept hierarchy, and +latent semantic relationships among the +entities mentioned in the text. As a case +study, we apply the model to a corpus +of Web documents from the software domain, and evaluate the accuracy of the various components of the learned ontology. diff --git a/_publications/nguyen2013lexical.markdown b/_publications/nguyen2013lexical.markdown new file mode 100644 index 00000000..9b6c97b9 --- /dev/null +++ b/_publications/nguyen2013lexical.markdown @@ -0,0 +1,23 @@ +--- +layout: publication +title: "Lexical Statistical Machine Translation for Language Migration" +authors: A. T. Nguyen, T. T. Nguyen, T. N. Nguyen +conference: FSE +year: 2013 +bibkey: nguyen2013lexical +--- +Prior research has shown that source code also exhibits naturalness, i.e. it is written by humans and is likely to be +repetitive. The researchers also showed that the n-gram language model is useful in predicting the next token in a source +file given a large corpus of existing source code. In this paper, we investigate how well statistical machine translation +(SMT) models for natural languages could help in migrating source code from one programming language to another. +We treat source code as a sequence of lexical tokens and +apply a phrase-based SMT model on the lexemes of those +tokens. Our empirical evaluation on migrating two Java +projects into C# showed that lexical, phrase-based SMT +could achieve high lexical translation accuracy ( BLEU from +81.3-82.6%). Users would have to manually edit only 11.9-15.8% of the total number of tokens in the resulting code to +correct it. However, a high percentage of total translation +methods (49.5-58.6%) is syntactically incorrect. Therefore, +our result calls for a more program-oriented SMT model that +is capable of better integrating the syntactic and semantic +information of a program to support language migration. diff --git a/_publications/nguyen2013statistical.markdown b/_publications/nguyen2013statistical.markdown new file mode 100644 index 00000000..7f06ed3b --- /dev/null +++ b/_publications/nguyen2013statistical.markdown @@ -0,0 +1,18 @@ +--- +layout: publication +title: "A Statistical Semantic Language Model for Source Code" +authors: T.T. Nguyen, A.T. Nguyen, H.A. Nguyen, T.N. Nguyen +conference: FSE +year: 2013 +bibkey: nguyen2013statistical +--- +Recent research has successfully applied the statistical n-gram language model to show that source code exhibits a +good level of repetition. The n-gram model is shown to have +good predictability in supporting code suggestion and completion. However, the state-of-the-art n-gram approach to +capture source code regularities/patterns is based only on +the lexical information in a local context of the code units. +To improve predictability, we introduce SLAMC, a novel statistical semantic language model for source code. It incorporates semantic information into code tokens and models the +regularities/patterns of such semantic annotations, called sememes, rather than their lexemes. It combines the local context in semantic n-grams with the global technical concerns/functionality into an n-gram topic model, together with pairwise associations of program elements. Based on SLAMC, +we developed a new code suggestion method, which is empirically evaluated on several projects to have relatively 18–68% +higher accuracy than the state-of-the-art approach. + diff --git a/_publications/nguyen2013study.markdown b/_publications/nguyen2013study.markdown new file mode 100644 index 00000000..9948be02 --- /dev/null +++ b/_publications/nguyen2013study.markdown @@ -0,0 +1,25 @@ +--- +layout: publication +title: "A Study of Repetitiveness of Code Changes in Software Evolution" +authors: H.A. Nguyen, A.T. Nguyen, T.T. Nguyen, T.N. Nguyen, H. Rajan +conference: ASE +year: 2013 +bibkey: nguyen2013study +--- +In this paper, we present a large-scale study of +repetitiveness of code changes in software evolution. We collected +a large data set of 2,841 Java projects, with 1.7 billion source lines +of code (SLOC) at the latest revisions, 1.8 million code change +revisions (0.4 million fixes), 6.2 million changed files, and 2.5 +billion changed SLOCs. A change is considered repeated within +or cross-project if it matches another change having occurred +in the history of the project or another project, respectively. We +report the following important findings. First, repetitiveness of +changes could be as high as 70–100% at small sizes and decreases +exponentially as size increases. Second, repetitiveness is higher +and more stable in the cross-project setting than in the project-within one. Third, fixing changes repeat similarly to general +changes. Importantly, learning code changes and recommending +them in software evolution is beneficial with accuracy for top-1 +recommendation of over 30% and top-3 of nearly 35%. Repeated +fixing changes could also be useful for automatic program repair. + diff --git a/_publications/nguyen2014statistical.markdown b/_publications/nguyen2014statistical.markdown new file mode 100644 index 00000000..ebed352f --- /dev/null +++ b/_publications/nguyen2014statistical.markdown @@ -0,0 +1,23 @@ +--- +layout: publication +title: "Statistical Learning Approach for Mining API Usage Mappings for Code Migration" +authors: A.T. Nguyen, H.A. Nguyen, T.T. Nguyen, T.N. Nguyen +conference: ASE +year: 2014 +bibkey: nguyen2014statistical +--- +The same software product nowadays could appear in multiple platforms and devices. To address business needs, software companies +develop a software product in a programming language and then +migrate it to another one. To support that process, semi-automatic +migration tools have been proposed. However, they require users +to manually define the mappings between the respective APIs of +the libraries used in two languages. To reduce such manual effort, +we introduce StaMiner, a novel data-driven approach that statistically learns the mappings between APIs from the corpus of the +corresponding client code of the APIs in two languages Java and +C#. Instead of using heuristics on the textual or structural similarity +between APIs in two languages to map API methods and classes +as in existing mining approaches, StaMiner is based on a statistical +model that learns the mappings in such a corpus and provides mappings for APIs with all possible arities. Our empirical evaluation +on several projects shows that StaMiner can detect API usage mappings with higher accuracy than a state-of-the-art approach. With +the resulting API mappings mined by StaMiner, Java2CSharp, an +existing migration tool, could achieve a higher level of accuracy. diff --git a/_publications/nguyen2015divide.markdown b/_publications/nguyen2015divide.markdown new file mode 100644 index 00000000..c8d1a33b --- /dev/null +++ b/_publications/nguyen2015divide.markdown @@ -0,0 +1,28 @@ +--- +layout: publication +title: "Divide-and-Conquer Approach for Multi-phase Statistical Migration for Source Code" +authors: A.T. Nguyen, T.T. Nguyen, T.N. Nguyen +conference: ASE +year: 2014 +bibkey: nguyen2015divide +--- +Prior research shows that directly applying phrase-based SMT on lexical tokens to migrate Java to C# produces +much semantically incorrect code. A key limitation is the use of +sequences in phrase-based SMT to model and translate source +code with well-formed structures. We propose mppSMT, a divideand-conquer technique to address that with novel training and migration algorithms using phrase-based SMT in three phases. First, +mppSMT treats a program as a sequence of syntactic units and +maps/translates such sequences in two languages to one another. +Second, with a syntax-directed fashion, it deals with the tokens +within syntactic units by encoding them with semantic symbols to +represent their data and token types. This encoding via semantic +symbols helps better migration of API usages. Third, the lexical +tokens corresponding to each sememe are mapped or migrated. +The resulting sequences of tokens are merged together to form +the final migrated code. Such divide-and-conquer and syntax-direction strategies enable phrase-based SMT to adapt well to +syntactical structures in source code, thus, improving migration +accuracy. Our empirical evaluation on several real-world systems +shows that 84.8–97.9% and 70–83% of the migrated methods are +syntactically and semantically correct, respectively. 26.3–51.2% +of total migrated methods are exactly matched to the human-written C# code in the oracle. Compared to Java2CSharp, a rule-based migration tool, it achieves higher semantic accuracy from +6.6–57.7% relatively. Importantly, it does not require manual +labeling for training data or manual definition of rules. diff --git a/_publications/nguyen2015graph.markdown b/_publications/nguyen2015graph.markdown new file mode 100644 index 00000000..1fffa1a3 --- /dev/null +++ b/_publications/nguyen2015graph.markdown @@ -0,0 +1,25 @@ +--- +layout: publication +title: "Graph-based Statistical Language Model for Code" +authors: A.T. Nguyen, T.N. Nguyen +conference: ICSE +year: 2015 +bibkey: nguyen2015graph +--- +n-gram statistical language model has been successfully applied to capture programming patterns to support code +completion and suggestion. However, the approaches using n-gram face challenges in capturing the patterns at higher levels +of abstraction due to the mismatch between the sequence nature +in n-grams and the structure nature of syntax and semantics +in source code. This paper presents GraLan, a graph-based +statistical language model and its application in code suggestion. GraLan can learn from a source code corpus and compute +the appearance probabilities of any graphs given the observed +(sub)graphs. We use GraLan to develop an API suggestion +engine and an AST-based language model, ASTLan. ASTLan +supports the suggestion of the next valid syntactic template +and the detection of common syntactic templates. Our empirical +evaluation on a large corpus of open-source projects has shown +that our engine is more accurate in API code suggestion than +the state-of-the-art approaches, and in 75% of the cases, it can +correctly suggest the API with only five candidates. ASTLan also +has high accuracy in suggesting the next syntactic template and +is able to detect many useful and common syntactic templates. diff --git a/_publications/nguyen2015learning.markdown b/_publications/nguyen2015learning.markdown new file mode 100644 index 00000000..c28f6419 --- /dev/null +++ b/_publications/nguyen2015learning.markdown @@ -0,0 +1,25 @@ +--- +layout: publication +title: "Learning API Usages from Bytecode: A Statistical Approach" +authors: T.T. Nguyen, H.V. Pham, P.M. Vu, T.T. Nguyen +conference: ICSE +year: 2015 +bibkey: nguyen2015learning +--- +When developing mobile apps, programmers rely +heavily on standard API frameworks and libraries. However, +learning and using those APIs is often challenging due to the +fast-changing nature of API frameworks for mobile systems, the +complexity of API usages, the insufficiency of documentation, +and the unavailability of source code examples. In this paper, we +propose a novel approach to learn API usages from bytecode +of Android mobile apps. Our core contributions include: i) +ARUS, a graph-based representation of API usage scenarios; +ii) HAPI, a statistical, generative model of API usages; and iii) +three algorithms to extract ARUS from apps’ bytecode, to train +HAPI based on method call sequences extracted from ARUS, and +to recommend method calls in code completion engines using +the trained HAPI. Our empirical evaluation suggests that our +approach can learn useful API usage models which can provide +recommendations with higher levels of accuracy than the baseline +n-gram model. diff --git a/_publications/nguyen2016mapping.markdown b/_publications/nguyen2016mapping.markdown new file mode 100644 index 00000000..628290eb --- /dev/null +++ b/_publications/nguyen2016mapping.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Mapping API Elements for Code Migration with Vector Representations" +authors: T.D. Nguyen, A.T. Nguyen, T.N. Nguyen +conference: ICSE +year: 2016 +bibkey: nguyen2016mapping +--- + diff --git a/_publications/nguyen2017exploring.markdown b/_publications/nguyen2017exploring.markdown new file mode 100644 index 00000000..53785eea --- /dev/null +++ b/_publications/nguyen2017exploring.markdown @@ -0,0 +1,32 @@ +--- +layout: publication +title: "Exploring API Embedding for API Usages and Applications" +authors: T.D. Nguyen, A.T. Nguyen, H.D. Phan, T.N. Nguyen +conference: ICSE +year: 2017 +bibkey: nguyen2017exploring +--- +Word2Vec is a class of neural network models that +as being trained from a large corpus of texts, they can produce for +each unique word a corresponding vector in a continuous space in +which linguistic contexts of words can be observed. In this work, +we study the characteristics of Word2Vec vectors, called API 2 VEC +or API embeddings, for the API elements within the API sequences in source code. Our empirical study shows that the close +proximity of the API 2 VEC vectors for API elements reflects the +similar usage contexts containing the surrounding APIs of those +API elements. Moreover, API 2 VEC can capture several similar +semantic relations between API elements in API usages via vector +offsets. We demonstrate the usefulness of API 2 VEC vectors for +API elements in three applications. First, we build a tool that mines the pairs of API elements that share the same usage relations +among them. The other applications are in the code migration +domain. We develop API 2 API , a tool to automatically learn the +API mappings between Java and C# using a characteristic of the +API 2 VEC vectors for API elements in the two languages: semantic +relations among API elements in their usages are observed in the +two vector spaces for the two languages as similar geometric +arrangements among their API 2 VEC vectors. Our empirical +evaluation shows that API 2 API relatively improves 22.6% and +40.1% top-1 and top-5 accuracy over a state-of-the-art mining +approach for API mappings. Finally, as another application in +code migration, we are able to migrate equivalent API usages +from Java to C# with up to 90.6% recall and 87.2% precision. diff --git a/_publications/oda2015learning.markdown b/_publications/oda2015learning.markdown new file mode 100644 index 00000000..80e16e88 --- /dev/null +++ b/_publications/oda2015learning.markdown @@ -0,0 +1,24 @@ +--- +layout: publication +title: "Learning to Generate Pseudo-code from Source Code using Statistical Machine Translation" +authors: Y. Oda, H. Fudaba, G. Neubig, H. Hata, S. Sakti, T. Toda, and S. Nakamura +conference: ASE +year: 2015 +bibkey: oda2015learning +--- +Pseudo-code written in natural language can aid +the comprehension of source code in unfamiliar programming +languages. However, the great majority of source code has no +corresponding pseudo-code, because pseudo-code is redundant +and laborious to create. If pseudo-code could be generated +automatically and instantly from given source code, we could +allow for on-demand production of pseudo-code without human +effort. In this paper, we propose a method to automatically +generate pseudo-code from source code, specifically adopting the +statistical machine translation (SMT) framework. SMT, which +was originally designed to translate between two natural languages, allows us to automatically learn the relationship between +source code/pseudo-code pairs, making it possible to create a +pseudo-code generator with less human effort. In experiments, +we generated English or Japanese pseudo-code from Python +statements using SMT, and find that the generated pseudo-code +is largely accurate, and aids code understanding. diff --git a/_publications/oh2015learning.markdown b/_publications/oh2015learning.markdown new file mode 100644 index 00000000..fa32994e --- /dev/null +++ b/_publications/oh2015learning.markdown @@ -0,0 +1,29 @@ +--- +layout: publication +title: "Learning a Strategy for Adapting a Program Analysis via Bayesian Optimisation" +authors: H. Oh, H. Yang, K, Yi +conference: OOPSLA +year: 2015 +bibkey: oh2015learning +--- +Building a cost-effective static analyser for real-world programs is still regarded an art. One key contributor to this +grim reputation is the difficulty in balancing the cost and the +precision of an analyser. An ideal analyser should be adap- +tive to a given analysis task, and avoid using techniques that +unnecessarily improve precision and increase analysis cost. +However, achieving this ideal is highly nontrivial, and it requires a large amount of engineering efforts. + +In this paper we present a new approach for building +an adaptive static analyser. In our approach, the analyser +includes a sophisticated parameterised strategy that decides, for each part of a given program, whether to apply +a precision-improving technique to that part or not. We +present a method for learning a good parameter for such +a strategy from an existing codebase via Bayesian optimisation. The learnt strategy is then used for new, unseen programs. Using our approach, we developed partially flow- +and context-sensitive variants of a realistic C static analyser. +The experimental results demonstrate that using Bayesian +optimisation is crucial for learning from an existing codebase. Also, they show that among all program queries that +require flow- or context-sensitivity, our partially flow- and +context-sensitive analysis answers the 75% of them, while +increasing the analysis cost only by 3.3x of the baseline +flow- and context-insensitive analysis, rather than 40x or +more of the fully sensitive version. diff --git a/_publications/omar2013structured.markdown b/_publications/omar2013structured.markdown new file mode 100644 index 00000000..f0734b8b --- /dev/null +++ b/_publications/omar2013structured.markdown @@ -0,0 +1,18 @@ +--- +layout: publication +title: "Structured Statistical Syntax Tree Prediction" +authors: C.Omar +conference: SPLASH +year: 2013 +bibkey: omar2013structured +--- +Statistical models of source code can be used to improve +code completion systems, assistive interfaces, and code +compression engines. We are developing a statistical model +where programs are represented as syntax trees, rather than +simply a stream of tokens. Our model, initially for the Java +language, combines corpus data with information about syntax, types and the program context. We tested this model +using open source code corpuses and find that our model +is significantly more accurate than the current state of the +art, providing initial evidence for our claim that combining +structural and statistical information is a fruitful strategy. From 81d73c5c368dbf8a4b1b347cd4643543331e969a Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sat, 16 Sep 2017 22:38:37 +0100 Subject: [PATCH 18/98] Fixes --- _data/allamanistaxonomy.yml | 2 +- .../{movshovitz2015kblda.markdown => movshovitz2015kb.markdown} | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) rename _publications/{movshovitz2015kblda.markdown => movshovitz2015kb.markdown} (97%) diff --git a/_data/allamanistaxonomy.yml b/_data/allamanistaxonomy.yml index 5297bbcf..3a90045c 100644 --- a/_data/allamanistaxonomy.yml +++ b/_data/allamanistaxonomy.yml @@ -85,7 +85,7 @@ - {bibkey: zaremba2014learning, categories: [representational], input_rep: Characters , modeled_target: Execution Trace , intermediate_rep: Distributed , application: --- } # Pattern Models -- {bibkey: allamanis2016mining, categories: [pattern], representation: Abstracted AST , pattern_type: Graphical Model , application: Semantic Idiom Mining } +- {bibkey: allamanis2017mining, categories: [pattern], representation: Abstracted AST , pattern_type: Graphical Model , application: Semantic Idiom Mining } - {bibkey: fowkes2016parameter, categories: [pattern], representation: API Call Sequences , pattern_type: Graphical Model , application: API Mining } - {bibkey: murali2017bayesian, categories: [pattern], representation: Sketch Synthesis , pattern_type: Graphical Model , application: Sketch Mining } - {bibkey: murali2017finding, categories: [pattern], representation: API Usage Errors , pattern_type: Graphical Model , application: Defect Prediction } diff --git a/_publications/movshovitz2015kblda.markdown b/_publications/movshovitz2015kb.markdown similarity index 97% rename from _publications/movshovitz2015kblda.markdown rename to _publications/movshovitz2015kb.markdown index 789e7c89..376a3ead 100644 --- a/_publications/movshovitz2015kblda.markdown +++ b/_publications/movshovitz2015kb.markdown @@ -4,7 +4,7 @@ title: "KB-LDA: Jointly Learning a Knowledge Base of Hierarchy, Relations, and F authors: D. Movshovitz-Attias, W. W. Cohen conference: ACL year: 2015 -bibkey: movshovitz2015kblda +bibkey: movshovitz2015kb --- Many existing knowledge bases (KBs), including Freebase, Yago, and NELL, rely on a fixed ontology, given as an input From 34668c079425834384d84aca3ba0e26adb80a2f3 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sat, 16 Sep 2017 23:11:46 +0100 Subject: [PATCH 19/98] Added more publications. --- _publications/piech2015learning.markdown | 17 ++++++++ _publications/proksch2015intelligent.markdown | 24 +++++++++++ _publications/ray2015naturalness.markdown | 23 ++++++++++ _publications/raychev2014code.markdown | 21 +++++++++ _publications/raychev2015predicting.markdown | 30 +++++++++++++ _publications/raychev2016learning.markdown | 43 +++++++++++++++++++ _publications/saraiva2015products.markdown | 30 +++++++++++++ _publications/sharma2015nirmal.markdown | 37 ++++++++++++++++ _publications/tu2014localness.markdown | 26 +++++++++++ .../vasilescu2017recovering.markdown | 10 +++++ _publications/wang2016automatically.markdown | 30 +++++++++++++ _publications/white2015toward.markdown | 35 +++++++++++++++ _publications/white2016deep.markdown | 27 ++++++++++++ _publications/yadid2016extracting.markdown | 25 +++++++++++ _publications/yin2017syntactic.markdown | 18 ++++++++ 15 files changed, 396 insertions(+) create mode 100644 _publications/piech2015learning.markdown create mode 100644 _publications/proksch2015intelligent.markdown create mode 100644 _publications/ray2015naturalness.markdown create mode 100644 _publications/raychev2014code.markdown create mode 100644 _publications/raychev2015predicting.markdown create mode 100644 _publications/raychev2016learning.markdown create mode 100644 _publications/saraiva2015products.markdown create mode 100644 _publications/sharma2015nirmal.markdown create mode 100644 _publications/tu2014localness.markdown create mode 100644 _publications/vasilescu2017recovering.markdown create mode 100644 _publications/wang2016automatically.markdown create mode 100644 _publications/white2015toward.markdown create mode 100644 _publications/white2016deep.markdown create mode 100644 _publications/yadid2016extracting.markdown create mode 100644 _publications/yin2017syntactic.markdown diff --git a/_publications/piech2015learning.markdown b/_publications/piech2015learning.markdown new file mode 100644 index 00000000..1ef6e62b --- /dev/null +++ b/_publications/piech2015learning.markdown @@ -0,0 +1,17 @@ +--- +layout: publication +title: "Learning Program Embeddings to Propagate Feedback on Student Code" +authors: C. Piech, J. Huang, A. Nguyen, M. Phulsuksombati, M, Sahami, L. Guibas +conference: ICML +year: 2015 +bibkey: piech2015learning +--- +Providing feedback, both assessing final work +and giving hints to stuck students, is difficult +for open-ended assignments in massive online +classes which can range from thousands to millions of students. We introduce a neural network +method to encode programs as a linear mapping +from an embedded precondition space to an embedded postcondition space and propose an algorithm for feedback at scale using these linear maps as features. We apply our algorithm +to assessments from the Code.org Hour of Code +and Stanford University’s CS1 course, where we +propagate human comments on student assignments to orders of magnitude more submissions. diff --git a/_publications/proksch2015intelligent.markdown b/_publications/proksch2015intelligent.markdown new file mode 100644 index 00000000..000ece60 --- /dev/null +++ b/_publications/proksch2015intelligent.markdown @@ -0,0 +1,24 @@ +--- +layout: publication +title: "Intelligent Code Completion with Bayesian Networks" +authors: S. Proksch, J. Lerch, M. Mezini +conference: TSE +year: 2015 +bibkey: proksch2015intelligent +--- +Code completion is an integral part of modern Integrated Development Environments (IDEs). Developers +often use it to explore Application Programming Interfaces (APIs). It is also useful to reduce the required +amount of typing and to help avoid typos. Traditional code completion systems propose all type-correct +methods to the developer. Such a list is often very long with many irrelevant items. More intelligent code +completion systems have been proposed in prior work to reduce the list of proposed methods to relevant +items. + +This work extends one of these existing approaches, the Best Matching Neighbor (BMN) algorithm. We +introduce Bayesian networks as an alternative underlying model, use additional context information for +more precise recommendations, and apply clustering techniques to improve model sizes. We compare our +new approach, Pattern-based Bayesian Networks (PBN), to the existing BMN algorithm. We extend previously used evaluation methodologies and, in addition to prediction quality, we also evaluate model size and +inference speed. + +Our results show that the additional context information we collect improves prediction quality, especially +for queries that do not contain method calls. We also show that PBN can obtain comparable prediction +quality to BMN, while model size and inference speed scale better with large input sizes. diff --git a/_publications/ray2015naturalness.markdown b/_publications/ray2015naturalness.markdown new file mode 100644 index 00000000..1abbbe3a --- /dev/null +++ b/_publications/ray2015naturalness.markdown @@ -0,0 +1,23 @@ +--- +layout: publication +title: "On the “Naturalness” of Buggy Code" +authors: B. Ray, V. Hellendoorn, S. Godhane, Z. Tu, A. Bacchelli, P. Devanbu +conference: ICSE +year: 2015 +bibkey: ray2015naturalness +--- +Real software, the kind working programmers produce by the kLOC +to solve real-world problems, tends to be “natural”, like speech or +natural language; it tends to be highly repetitive and predictable. +Researchers have captured this naturalness of software through statistical models and used them to good effect in suggestion engines, +porting tools, coding standards checkers, and idiom miners. This +suggests that code that appears improbable, or surprising, to a good +statistical language model is “unnatural” in some sense, and thus +possibly suspicious. In this paper, we investigate this hypothesis. We consider a large corpus of bug fix commits (ca. 8,296), +from 10 different Java projects, and we focus on its language statistics, evaluating the naturalness of buggy code and the corresponding fixes. We find that code with bugs tends to be more entropic +(i.e. unnatural), becoming less so as bugs are fixed. Focusing on +highly entropic lines is similar in cost-effectiveness to some well-known static bug finders (PMD, FindBugs) and ordering warnings +from these bug finders using an entropy measure improves the cost-effectiveness of inspecting code implicated in warnings. This suggests that entropy may be a valid language-independent and simple +way to complement the effectiveness of PMD or FindBugs, and +that search-based bug-fixing methods may benefit from using entropy both for fault-localization and searching for fixes. + diff --git a/_publications/raychev2014code.markdown b/_publications/raychev2014code.markdown new file mode 100644 index 00000000..bc8e37da --- /dev/null +++ b/_publications/raychev2014code.markdown @@ -0,0 +1,21 @@ +--- +layout: publication +title: "Code Completion with Statistical Language Models" +authors: V. Raychev, M. Vechev, E. Yahav +conference: PLDI +year: 2014 +bibkey: raychev2014code +--- +We address the problem of synthesizing code completions for programs using APIs. Given a program with holes, we synthesize completions for holes with the most likely sequences of method calls. + +Our main idea is to reduce the problem of code completion to +a natural-language processing problem of predicting probabilities +of sentences. We design a simple and scalable static analysis that +extracts sequences of method calls from a large codebase, and +index these into a statistical language model. We then employ +the language model to find the highest ranked sentences, and use +them to synthesize a code completion. Our approach is able to +synthesize sequences of calls across multiple objects together with +their arguments. + +Experiments show that our approach is fast and effective. Virtually all computed completions typecheck, and the desired completion appears in the top 3 results in 90% of the cases. diff --git a/_publications/raychev2015predicting.markdown b/_publications/raychev2015predicting.markdown new file mode 100644 index 00000000..edb6dd1f --- /dev/null +++ b/_publications/raychev2015predicting.markdown @@ -0,0 +1,30 @@ +--- +layout: publication +title: "Predicting Program Properties from “Big Code”" +authors: V. Raychev, M. Vechev, A. Krause +conference: POPL +year: 2015 +bibkey: raychev2015predicting +--- +We present a new approach for predicting program properties from +massive codebases (aka “Big Code”). Our approach first learns a +probabilistic model from existing data and then uses this model to +predict properties of new, unseen programs. + +The key idea of our work is to transform the input program into +a representation which allows us to phrase the problem of inferring program properties as structured prediction in machine learning. This formulation enables us to leverage powerful probabilistic +graphical models such as conditional random fields (CRFs) in order +to perform joint prediction of program properties. + +As an example of our approach, we built a scalable prediction +engine called JSNICE 1 for solving two kinds of problems in the +context of JavaScript: predicting (syntactic) names of identifiers +and predicting (semantic) type annotations of variables. Experimentally, JSNICE predicts correct names for 63% of name identifiers and its type annotation predictions are correct in 81% of the +cases. In the first week since its release, JSN ICE was used by more +than 30,000 developers and in only few months has become a popular tool in the JavaScript developer community. + +By formulating the problem of inferring program properties as +structured prediction and showing how to perform both learning +and inference in this context, our work opens up new possibilities +for attacking a wide range of difficult problems in the context of +“Big Code” including invariant generation, de-compilation, synthesis and others. diff --git a/_publications/raychev2016learning.markdown b/_publications/raychev2016learning.markdown new file mode 100644 index 00000000..05be72d0 --- /dev/null +++ b/_publications/raychev2016learning.markdown @@ -0,0 +1,43 @@ +--- +layout: publication +title: "Learning Programs from Noisy Data" +authors: V. Raychev, P. Bielik, M. Vechev, A. Krause +conference: POPL +year: 2016 +bibkey: raychev2016learning +--- +We present a new approach for learning programs from noisy +datasets. Our approach is based on two new concepts: a regularized +program generator which produces a candidate program based on a +small sample of the entire dataset while avoiding overfitting, and a +dataset sampler which carefully samples the dataset by leveraging +the candidate program’s score on that dataset. The two components +are connected in a continuous feedback-directed loop. + +We show how to apply this approach to two settings: one where +the dataset has a bound on the noise, and another without a noise +bound. The second setting leads to a new way of performing +approximate empirical risk minimization on hypotheses classes +formed by a discrete search space. + +We then present two new kinds of program synthesizers which +target the two noise settings. First, we introduce a novel regularized +bitstream synthesizer that successfully generates programs even in +the presence of incorrect examples. We show that the synthesizer +can detect errors in the examples while combating overfitting – +a major problem in existing synthesis techniques. We also show +how the approach can be used in a setting where the dataset grows +dynamically via new examples (e.g., provided by a human). + +Second, we present a novel technique for constructing statistical +code completion systems. These are systems trained on massive +datasets of open source programs, also known as “Big Code”. The +key idea is to introduce a domain specific language (DSL) over +trees and to learn functions in that DSL directly from the dataset. +These learned functions then condition the predictions made by the +system. This is a flexible and powerful technique which generalizes +several existing works as we no longer need to decide a priori on +what the prediction should be conditioned (another benefit is that +the learned functions are a natural mechanism for explaining the +prediction). As a result, our code completion system surpasses the +prediction capabilities of existing, hard-wired systems. diff --git a/_publications/saraiva2015products.markdown b/_publications/saraiva2015products.markdown new file mode 100644 index 00000000..6971e301 --- /dev/null +++ b/_publications/saraiva2015products.markdown @@ -0,0 +1,30 @@ +--- +layout: publication +title: "Products, Developers, and Milestones: How Should I Build My N-Gram Language Model" +authors: C. Saraiva, C. Bird, T. Zimmermann +conference: FSE +year: 2015 +bibkey: saraiva2015products +--- +Recent work has shown that although programming languages en- +able source code to be rich and complex, most code tends to be +repetitive and predictable. The use of natural language processing +(NLP) techniques applied to source code such as n-gram language +models show great promise in areas such as code completion, aiding impaired developers, and code search. In this paper, we address +three questions related to different methods of constructing lan- +guage models in an industrial context. Specifically, we ask: (1) Do +application specific, but smaller language models perform better +than language models across applications? (2) Are developer specific language models effective and do they differ depending on +what parts of the codebase a developer is working in? (3) Finally, +do language models change over time, i.e., does a language model +from early development model change later on in development? +The answers to these questions enable techniques that make use of +programming language models in development to choose the model +training corpus more effectively. + +We evaluate these questions by building 28 language models across +developers, time periods, and applications within Microsoft Office +and present the results in this paper. We find that developer and +application specific language models perform better than models +from the entire codebase, but that temporality has little to no effect +on language model performance. diff --git a/_publications/sharma2015nirmal.markdown b/_publications/sharma2015nirmal.markdown new file mode 100644 index 00000000..ceeb3c85 --- /dev/null +++ b/_publications/sharma2015nirmal.markdown @@ -0,0 +1,37 @@ +--- +layout: publication +title: "NIRMAL: Automatic Identification of Software Relevant Tweets Leveraging Language Model" +authors: A. Sharma, Y. Tian, D. Lo +conference: SANER +year: 2015 +bibkey: sharma2015nirmal +--- +Twitter is one of the most widely used social media +platforms today. It enables users to share and view short 140-character messages called “tweets”. About 284 million active +users generate close to 500 million tweets per day. Such rapid +generation of user generated content in large magnitudes results +in the problem of information overload. Users who are interested +in information related to a particular domain have limited means +to filter out irrelevant tweets and tend to get lost in the huge +amount of data they encounter. A recent study by Singer et +al. found that software developers use Twitter to stay aware of +industry trends, to learn from others, and to network with other +developers. However, Singer et al. also reported that developers +often find Twitter streams to contain too much noise which is a +barrier to the adoption of Twitter. In this paper, to help developers +cope with noise, we propose a novel approach named NIRMAL, +which automatically identifies software relevant tweets from a +collection or stream of tweets. Our approach is based on language +modeling which learns a statistical model based on a training +corpus (i.e., set of documents). We make use of a subset of posts +from StackOverflow, a programming question and answer site, as +a training corpus to learn a language model. A corpus of tweets +was then used to test the effectiveness of the trained language +model. The tweets were sorted based on the rank the model +assigned to each of the individual tweets. The top 200 tweets +were then manually analyzed to verify whether they are software +related or not, and then an accuracy score was calculated. The +results show that decent accuracy scores can be achieved by +various variants of NIRMAL, which indicates that NIRMAL can +effectively identify software related tweets from a huge corpus of +tweets. diff --git a/_publications/tu2014localness.markdown b/_publications/tu2014localness.markdown new file mode 100644 index 00000000..a45323e2 --- /dev/null +++ b/_publications/tu2014localness.markdown @@ -0,0 +1,26 @@ +--- +layout: publication +title: "On the Localness of Software" +authors: Z. Tu, Z. Su, P. Devanbu +conference: FSE +year: 2014 +bibkey: tu2014localness +--- +The n-gram language model, which has its roots in statistical natural +language processing, has been shown to successfully capture the +repetitive and predictable regularities (“naturalness") of source code, +and help with tasks such as code suggestion, porting, and designing +assistive coding devices. However, we show in this paper that this +natural-language-based model fails to exploit a special property of +source code: localness. We find that human-written programs are +localized: they have useful local regularities that can be captured +and exploited. We introduce a novel cache language model that +consists of both an n-gram and an added “cache" component to +exploit localness. We show empirically that the additional cache +component greatly improves the n-gram approach by capturing +the localness of software, as measured by both cross-entropy and +suggestion accuracy. Our model’s suggestion accuracy is actually +comparable to a state-of-the-art, semantically augmented language +model; but it is simpler and easier to implement. Our cache language +model requires nothing beyond lexicalization, and thus is applicable +to all programming languages. diff --git a/_publications/vasilescu2017recovering.markdown b/_publications/vasilescu2017recovering.markdown new file mode 100644 index 00000000..86a870ec --- /dev/null +++ b/_publications/vasilescu2017recovering.markdown @@ -0,0 +1,10 @@ +--- +layout: publication +title: "Recovering Clear, Natural Identifiers from Obfuscated JS Names" +authors: B. Vasilescu, C. Casalnuovo, P. Devanbu +conference: FSE +year: 2017 +bibkey: vasilescu2017recovering +--- + Well-chosen variable names are critical to source code readability, reusability, and maintainability. Unfortunately, in deployed JavaScript code (which is ubiquitous on the web) the identifier names are frequently minified and overloaded. This is done both for efficiency and also to protect potentially proprietary intellectual property. In this paper, we describe an approach based on statistical machine translation (SMT) that recovers some of the original names from the JavaScript programs minified by the very popular UglifyJS. This simple tool, Autonym, performs comparably to the best currently available deobfuscator for JavaScript, JSNice, which uses sophisticated static analysis. In fact, Autonym is quite complementary to JSNice, performing well when it does not, and vice versa. We also introduce a new tool, JSNaughty, which blends Autonym and JSNice, and significantly outperforms both at identifier name recovery, while remaining just as easy to use as JSNice. JSNaughty is available online at http://jsnaughty.org. + diff --git a/_publications/wang2016automatically.markdown b/_publications/wang2016automatically.markdown new file mode 100644 index 00000000..8d23b254 --- /dev/null +++ b/_publications/wang2016automatically.markdown @@ -0,0 +1,30 @@ +--- +layout: publication +title: "Automatically Learning Semantic Features for Defect Prediction" +authors: S. Wang, T. Liu, L. Tan +conference: ICSE +year: 2016 +bibkey: wang2016automatically +--- +Software defect prediction, which predicts defective code regions, can help developers find bugs and prioritize their testing efforts. To build accurate prediction models, previous +studies focus on manually designing features that encode the +characteristics of programs and exploring different machine +learning algorithms. Existing traditional features often fail +to capture the semantic differences of programs, and such a +capability is needed for building accurate prediction models. + +To bridge the gap between programs’ semantics and +defect prediction features, this paper proposes to leverage a +powerful representation-learning algorithm, deep learning, +to learn semantic representation of programs automatically +from source code. Specifically, we leverage Deep Belief +Network (DBN) to automatically learn semantic features +from token vectors extracted from programs’ Abstract +Syntax Trees (ASTs). + +Our evaluation on ten open source projects shows that +our automatically learned semantic features significantly improve both within-project defect prediction (WPDP) and +cross-project defect prediction (CPDP) compared to traditional features. Our semantic features improve WPDP on +average by 14.7% in precision, 11.5% in recall, and 14.2% +in F1. For CPDP, our semantic features based approach +outperforms the state-of-the-art technique TCA+ with traditional features by 8.9% in F1. diff --git a/_publications/white2015toward.markdown b/_publications/white2015toward.markdown new file mode 100644 index 00000000..4e029167 --- /dev/null +++ b/_publications/white2015toward.markdown @@ -0,0 +1,35 @@ +--- +layout: publication +title: "Toward Deep Learning Software Repositories" +authors: M. White, C. Vendome, M. Linares-Vásquez, D. Poshyvanyk +conference: MSR +year: 2015 +bibkey: white2015toward +--- +Deep learning subsumes algorithms that automatically learn compositional representations. The ability of these +models to generalize well has ushered in tremendous advances +in many fields such as natural language processing (NLP). +Recent research in the software engineering (SE) community +has demonstrated the usefulness of applying NLP techniques to +software corpora. Hence, we motivate deep learning for software +language modeling, highlighting fundamental differences between +state-of-the-practice software language models and connectionist +models. Our deep learning models are applicable to source +code files (since they only require lexically analyzed source +code written in any programming language) and other types +of artifacts. We show how a particular deep learning model +can remember its state to effectively model sequential data, +e.g., streaming software tokens, and the state is shown to be +much more expressive than discrete tokens in a prefix. Then we +instantiate deep learning models and show that deep learning +induces high-quality models compared to n-grams and cache-based n-grams on a corpus of Java projects. We experiment +with two of the models’ hyperparameters, which govern their +capacity and the amount of context they use to inform predictions, +before building several committees of software language models +to aid generalization. Then we apply the deep learning models to +code suggestion and demonstrate their effectiveness at a real SE +task compared to state-of-the-practice models. Finally, we propose +avenues for future work, where deep learning can be brought to +bear to support model-based testing, improve software lexicons, +and conceptualize software artifacts. Thus, our work serves as +the first step toward deep learning software repositories. diff --git a/_publications/white2016deep.markdown b/_publications/white2016deep.markdown new file mode 100644 index 00000000..c1f5e189 --- /dev/null +++ b/_publications/white2016deep.markdown @@ -0,0 +1,27 @@ +--- +layout: publication +title: "Deep Learning Code Fragments for Code Clone Detection" +authors: M. White, M. Tufano, C. Vendome, D. Poshyvanyk +conference: ASE +year: 2016 +bibkey: white2016deep +--- +Code clone detection is an important problem for software +maintenance and evolution. Many approaches consider either structure or identifiers, but none of the existing detection techniques model both sources of information. These +techniques also depend on generic, handcrafted features to +represent code fragments. We introduce learning-based detection techniques where everything for representing terms +and fragments in source code is mined from the repository. +Our code analysis supports a framework, which relies on +deep learning, for automatically linking patterns mined at +the lexical level with patterns mined at the syntactic level. +We evaluated our novel learning-based approach for code +clone detection with respect to feasibility from the point +of view of software maintainers. We sampled and manually +evaluated 398 file- and 480 method-level pairs across eight +real-world Java systems; 93% of the file- and method-level +samples were evaluated to be true positives. Among the true +positives, we found pairs mapping to all four clone types. We +compared our approach to a traditional structure-oriented +technique and found that our learning-based approach detected clones that were either undetected or suboptimally +reported by the prominent tool Deckard. Our results affirm +that our learning-based approach is suitable for clone detection and a tenable technique for researchers. diff --git a/_publications/yadid2016extracting.markdown b/_publications/yadid2016extracting.markdown new file mode 100644 index 00000000..26083781 --- /dev/null +++ b/_publications/yadid2016extracting.markdown @@ -0,0 +1,25 @@ +--- +layout: publication +title: "Extracting Code from Programming Tutorial Videos" +authors: S. Yadid, E. Yahav +conference: Onward! +year: 2016 +bibkey: yadid2016extracting +--- +The number of programming tutorial videos on the web +increases daily. Video hosting sites such as YouTube host +millions of video lectures, with many programming tutorials for various languages and platforms. These videos contain a wealth of valuable information, including code that +may be of interest. However, two main challenges have so +far prevented the effective indexing of programming tutorial +videos: (i) code in tutorials is typically written on-the-fly, +with only parts of the code visible in each frame, and (ii) optical character recognition (OCR) is not precise enough to +produce quality results from videos. + +We present a novel approach for extracting code from +videos that is based on: (i) consolidating code across frames, +and (ii) statistical language models for applying corrections +at different levels, allowing us to make corrections by choosing the most likely token, combination of tokens that form a +likely line structure, and combination of lines that lead to +a likely code fragment in a particular language. We implemented our approach in a tool called ACE , and used it to extract code from 40 Android video tutorials on YouTube . Our +evaluation shows that ACE extracts code with high accuracy, +enabling deep indexing of video tutorials. diff --git a/_publications/yin2017syntactic.markdown b/_publications/yin2017syntactic.markdown new file mode 100644 index 00000000..41071aca --- /dev/null +++ b/_publications/yin2017syntactic.markdown @@ -0,0 +1,18 @@ +--- +layout: publication +title: "A Syntactic Neural Model for General-Purpose Code Generation" +authors: P. Yin, G. Neubig +conference: ACL +year: 2017 +bibkey: yin2017syntactic +--- +We consider the problem of parsing natural language descriptions into source code +written in a general-purpose programming +language like Python. Existing data-driven methods treat this problem as a language generation task without considering +the underlying syntax of the target programming language. Informed by previous work in semantic parsing, in this paper we propose a novel neural architecture +powered by a grammar model to explicitly +capture the target syntax as prior knowledge. Experiments find this an effective +way to scale up to generation of complex +programs from natural language descriptions, achieving state-of-the-art results that +well outperform previous code generation +and semantic parsing approaches. From 5e6e1045403b521a0d55fc3066c0c1df55786dc7 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sun, 17 Sep 2017 00:16:07 +0100 Subject: [PATCH 20/98] Added more work. --- _data/allamanistaxonomy.yml | 6 ++-- _publications/bichsel2016statistical.markdown | 12 ++++++++ _publications/chae2016automatically.markdown | 9 ++++++ _publications/dam2016deep.markdown | 9 ++++++ _publications/guo2017semantically.markdown | 9 ++++++ _publications/gupta2017deepfix.markdown | 21 ++++++++++++++ _publications/hu2017codesum.markdown | 9 ++++++ _publications/iyer2016summarizing.markdown | 27 +++++++++++++++++ _publications/jiang2017automatically.markdown | 9 ++++++ _publications/kremenek2007factor.markdown | 19 ++++++++++++ _publications/levy2017learning.markdown | 19 ++++++++++++ _publications/li2015gated.markdown | 9 ++++++ _publications/loyola2017neural.markdown | 9 ++++++ _publications/mou2016convolutional.markdown | 16 ++++++++++ _publications/murali2017bayesian.markdown | 28 ++++++++++++++++++ _publications/murali2017finding.markdown | 29 +++++++++++++++++++ _publications/rabinovich2017abstract.markdown | 9 ++++++ _publications/wang2016bugram.markdown | 16 ++++++++++ _publications/zaremba2014learning.markdown | 9 ++++++ 19 files changed, 271 insertions(+), 3 deletions(-) create mode 100644 _publications/bichsel2016statistical.markdown create mode 100644 _publications/chae2016automatically.markdown create mode 100644 _publications/dam2016deep.markdown create mode 100644 _publications/guo2017semantically.markdown create mode 100644 _publications/gupta2017deepfix.markdown create mode 100644 _publications/hu2017codesum.markdown create mode 100644 _publications/iyer2016summarizing.markdown create mode 100644 _publications/jiang2017automatically.markdown create mode 100644 _publications/kremenek2007factor.markdown create mode 100644 _publications/levy2017learning.markdown create mode 100644 _publications/li2015gated.markdown create mode 100644 _publications/loyola2017neural.markdown create mode 100644 _publications/mou2016convolutional.markdown create mode 100644 _publications/murali2017bayesian.markdown create mode 100644 _publications/murali2017finding.markdown create mode 100644 _publications/rabinovich2017abstract.markdown create mode 100644 _publications/wang2016bugram.markdown create mode 100644 _publications/zaremba2014learning.markdown diff --git a/_data/allamanistaxonomy.yml b/_data/allamanistaxonomy.yml index 3a90045c..6c0b2e35 100644 --- a/_data/allamanistaxonomy.yml +++ b/_data/allamanistaxonomy.yml @@ -61,17 +61,17 @@ - {bibkey: chae2016automatically, categories: [representational], input_rep: Data Flow Graph , modeled_target: Static Analysis , intermediate_rep: Localized , application: Program Analysis } - {bibkey: corley2015exploring, categories: [representational], input_rep: Tokens , modeled_target: Feature Location , intermediate_rep: Distributed , application: Feature Location } - {bibkey: cummins2017end, categories: [representational], input_rep: Tokens , modeled_target: Optimization Flags , intermediate_rep: Distributed , application: Optimization Heuristics } -- {bibkey: green2017learning, categories: [representational], input_rep: Statements, modeled_target: Alignment , intermediate_rep: Distributed , application: Decompiling } - {bibkey: gu2016deep, categories: [representational], input_rep: Natural Language , modeled_target: API Calls , intermediate_rep: Distributed , application: API Search } - {bibkey: guo2017semantically, categories: [representational], input_rep: Tokens , modeled_target: Traceability link , intermediate_rep: Distributed , application: Traceability } -- {bibkey: gupta2016deepfix, categories: [representational], input_rep: Tokens , modeled_target: Code Fix , intermediate_rep: Distributed , application: Code Fixing } +- {bibkey: gupta2017deepfix, categories: [representational], input_rep: Tokens , modeled_target: Code Fix , intermediate_rep: Distributed , application: Code Fixing } - {bibkey: hu2017codesum, categories: [representational], input_rep: Linearized AST , modeled_target: Natural Language , intermediate_rep: Distributed , application: Summarization } - {bibkey: iyer2016summarizing, categories: [representational], input_rep: Tokens , modeled_target: Natural Language , intermediate_rep: Distributed , application: Summarization } - {bibkey: jiang2017automatically, categories: [representational], input_rep: Tokens (Diff) , modeled_target: Natural Language , intermediate_rep: Distributed , application: Commit Message } - {bibkey: koc2017learning, categories: [representational], input_rep: Bytecode , modeled_target: False Positives , intermediate_rep: Distributed , application: Program Analysis } - {bibkey: kremenek2007factor, categories: [representational], input_rep: Partial PDG , modeled_target: Ownership , intermediate_rep: Factor (GM) , application: Pointer Ownership } -- {bibkey: loyola2017neural, categories: [representational], input_rep: Tokens (Diff) , modeled_target: Natural Language , intermediate_rep: Distributed , application: Explain code changes } +- {bibkey: levy2017learning, categories: [representational], input_rep: Statements, modeled_target: Alignment , intermediate_rep: Distributed , application: Decompiling } - {bibkey: li2015gated, categories: [representational], input_rep: Memory Heap , modeled_target: Separation Logic , intermediate_rep: Distributed , application: Verification } +- {bibkey: loyola2017neural, categories: [representational], input_rep: Tokens (Diff) , modeled_target: Natural Language , intermediate_rep: Distributed , application: Explain code changes } - {bibkey: mangal2015user, categories: [representational], input_rep: Logic + Feedback , modeled_target: Prob. Analysis , intermediate_rep: MaxSAT , application: Program Analysis } - {bibkey: movshovitz2013natural, categories: [representational], input_rep: Tokens , modeled_target: Code Comments , intermediate_rep: Directed GM , application: Comment Prediction } - {bibkey: mou2016convolutional, categories: [representational], input_rep: Syntax , modeled_target: Classification , intermediate_rep: Distributed , application: Task Classification } diff --git a/_publications/bichsel2016statistical.markdown b/_publications/bichsel2016statistical.markdown new file mode 100644 index 00000000..6aef7edc --- /dev/null +++ b/_publications/bichsel2016statistical.markdown @@ -0,0 +1,12 @@ +--- +layout: publication +title: "Statistical Deobfuscation of Android Applications" +authors: B. Bichsel, V. Raychev, P. Tsankov, M. Vechev +conference: CCS +year: 2016 +bibkey: bichsel2016statistical +--- +This work presents a new approach for deobfuscating Android APKs based on probabilistic learning of large code bases (termed "Big Code"). The key idea is to learn a probabilistic model over thousands of non-obfuscated Android applications and to use this probabilistic model to deobfuscate new, unseen Android APKs. The concrete focus of the paper is on reversing layout obfuscation, a popular transformation which renames key program elements such as classes, packages, and methods, thus making it difficult to understand what the program does. Concretely, the paper: (i) phrases the layout deobfuscation problem of Android APKs as structured prediction in a probabilistic graphical model, (ii) instantiates this model with a rich set of features and constraints that capture the Android setting, ensuring both semantic equivalence and high prediction accuracy, and (iii) shows how to leverage powerful inference and learning algorithms to achieve overall precision and scalability of the probabilistic predictions. + +We implemented our approach in a tool called DeGuard and used it to: (i) reverse the layout obfuscation performed by the popular ProGuard system on benign, open-source applications, (ii) predict third-party libraries imported by benign APKs (also obfuscated by ProGuard), and (iii) rename obfuscated program elements of Android malware. The experimental results indicate that DeGuard is practically effective: it recovers 79.1% of the program element names obfuscated with ProGuard, it predicts third-party libraries with accuracy of 91.3%, and it reveals string decoders and classes that handle sensitive data in Android malware. + diff --git a/_publications/chae2016automatically.markdown b/_publications/chae2016automatically.markdown new file mode 100644 index 00000000..a96d6231 --- /dev/null +++ b/_publications/chae2016automatically.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Automatically generating features for learning program analysis heuristics" +authors: K. Chae, H. Oh, K. Heo, H. Yang +conference: ArXiV 1612.09394 +year: 2016 +bibkey: chae2016automatically +--- +We present a technique for automatically generating features for data-driven program analyses. Recently data-driven approaches for building a program analysis have been proposed, which mine existing codebases and automatically learn heuristics for finding a cost-effective abstraction for a given analysis task. Such approaches reduce the burden of the analysis designers, but they do not remove it completely; they still leave the highly nontrivial task of designing so called features to the hands of the designers. Our technique automates this feature design process. The idea is to use programs as features after reducing and abstracting them. Our technique goes through selected program-query pairs in codebases, and it reduces and abstracts the program in each pair to a few lines of code, while ensuring that the analysis behaves similarly for the original and the new programs with respect to the query. Each reduced program serves as a boolean feature for program-query pairs. This feature evaluates to true for a given program-query pair when (as a program) it is included in the program part of the pair. We have implemented our approach for three real-world program analyses. Our experimental evaluation shows that these analyses with automatically-generated features perform comparably to those with manually crafted features. diff --git a/_publications/dam2016deep.markdown b/_publications/dam2016deep.markdown new file mode 100644 index 00000000..5d280799 --- /dev/null +++ b/_publications/dam2016deep.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "A deep language model for software code" +authors: H. K. Dam, T. Tran, T. Pham +conference: ArXiV 1608.02715 +year: 2016 +bibkey: dam2016deep +--- +Existing language models such as n-grams for software code often fail to capture a long context where dependent code elements scatter far apart. In this paper, we propose a novel approach to build a language model for software code to address this particular issue. Our language model, partly inspired by human memory, is built upon the powerful deep learning-based Long Short Term Memory architecture that is capable of learning long-term dependencies which occur frequently in software code. Results from our intrinsic evaluation on a corpus of Java projects have demonstrated the effectiveness of our language model. This work contributes to realizing our vision for DeepSoft, an end-to-end, generic deep learning-based framework for modeling software and its development process. diff --git a/_publications/guo2017semantically.markdown b/_publications/guo2017semantically.markdown new file mode 100644 index 00000000..24e37d62 --- /dev/null +++ b/_publications/guo2017semantically.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Semantically enhanced software traceability using deep learning techniques" +authors: J. Guo, J. Cheng, J. Cleland-Huang +conference: ICSE +year: 2017 +bibkey: guo2017semantically +--- +In most safety-critical domains the need for traceability is prescribed by certifying bodies. Trace links are generally created among requirements, design, source code, test cases and other artifacts; however, creating such links manually is time consuming and error prone. Automated solutions use information retrieval and machine learning techniques to generate trace links; however, current techniques fail to understand semantics of the software artifacts or to integrate domain knowledge into the tracing process and therefore tend to deliver imprecise and inaccurate results. In this paper, we present a solution that uses deep learning to incorporate requirements artifact semantics and domain knowledge into the tracing solution. We propose a tracing network architecture that utilizes Word Embedding and Recurrent Neural Network (RNN) models to generate trace links. Word embedding learns word vectors that represent knowledge of the domain corpus and RNN uses these word vectors to learn the sentence semantics of requirements artifacts. We trained 360 different configurations of the tracing network using existing trace links in the Positive Train Control domain and identified the Bidirectional Gated Recurrent Unit (BI-GRU) as the best model for the tracing task. BI-GRU significantly out-performed state-of-the-art tracing methods including the Vector Space Model and Latent Semantic Indexing. diff --git a/_publications/gupta2017deepfix.markdown b/_publications/gupta2017deepfix.markdown new file mode 100644 index 00000000..a0992c5d --- /dev/null +++ b/_publications/gupta2017deepfix.markdown @@ -0,0 +1,21 @@ +--- +layout: publication +title: "DeepFix: Fixing Common C Language Errors by Deep Learning" +authors: R. Gupta, S. Pal, A. Kanade, S. Shevade +conference: AAAI +year: 2017 +bibkey: gupta2017deepfix +--- +The problem of automatically fixing programming errors is a +very active research topic in software engineering. This is a +challenging problem as fixing even a single error may require +analysis of the entire program. In practice, a number of errors +arise due to programmer’s inexperience with the programming language or lack of attention to detail. We call these +common programming errors. These are analogous to grammatical errors in natural languages. Compilers detect such errors, but their error messages are usually inaccurate. In this +work, we present an end-to-end solution, called DeepFix, that +can fix multiple such errors in a program without relying on +any external tool to locate or fix them. At the heart of DeepFix +is a multi-layered sequence-to-sequence neural network with +attention which is trained to predict erroneous program locations along with the required correct statements. On a set of +6971 erroneous C programs written by students for 93 programming tasks, DeepFix could fix 1881 (27%) programs +completely and 1338 (19%) programs partially. diff --git a/_publications/hu2017codesum.markdown b/_publications/hu2017codesum.markdown new file mode 100644 index 00000000..1f84ade6 --- /dev/null +++ b/_publications/hu2017codesum.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "CodeSum: Translate Program Language to Natural Language" +authors: X. Hu, Y. Wei, G. Li, Z. Jin +conference: ArXiV 1708.01837 +year: 2017 +bibkey: hu2017codesum +--- +During software maintenance, programmers spend a lot of time on code comprehension. Reading comments is an effective way for programmers to reduce the reading and navigating time when comprehending source code. Therefore, as a critical task in software engineering, code summarization aims to generate brief natural language descriptions for source code. In this paper, we propose a new code summarization model named CodeSum. CodeSum exploits the attention-based sequence-to-sequence (Seq2Seq) neural network with Structure-based Traversal (SBT) of Abstract Syntax Trees (AST). The AST sequences generated by SBT can better present the structure of ASTs and keep unambiguous. We conduct experiments on three large-scale corpora in different program languages, i.e., Java, C#, and SQL, in which Java corpus is our new proposed industry code extracted from Github. Experimental results show that our method CodeSum outperforms the state-of-the-art significantly. diff --git a/_publications/iyer2016summarizing.markdown b/_publications/iyer2016summarizing.markdown new file mode 100644 index 00000000..5f76989a --- /dev/null +++ b/_publications/iyer2016summarizing.markdown @@ -0,0 +1,27 @@ +--- +layout: publication +title: "Summarizing Source Code using a Neural Attention Model" +authors: S. Iyer, I. Konstas, A. Cheung, L. Zettlemoyer +conference: ACL +year: 2016 +bibkey: iyer2016summarizing +--- +High quality source code is often paired +with high level summaries of the computation it performs, for example in code +documentation or in descriptions posted +in online forums. Such summaries are +extremely useful for applications such as +code search but are expensive to manually +author, hence only done for a small fraction of all code that is produced. In this +paper, we present the first completely data-driven approach for generating high level +summaries of source code. Our model, +CODE-NN , uses Long Short Term Memory (LSTM) networks with attention to +produce sentences that describe C# code +snippets and SQL queries. CODE-NN +is trained on a new corpus that is automatically collected from StackOverflow, +which we release. Experiments demonstrate strong performance on two tasks: +(1) code summarization, where we establish the first end-to-end learning results +and outperform strong baselines, and (2) +code retrieval, where our learned model +improves the state of the art on a recently +introduced C# benchmark by a large margin. diff --git a/_publications/jiang2017automatically.markdown b/_publications/jiang2017automatically.markdown new file mode 100644 index 00000000..7d7d5bd3 --- /dev/null +++ b/_publications/jiang2017automatically.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Automatically Generating Commit Messages from Diffs using Neural Machine Translation" +authors: S. Jiang, A. Armaly, C. McMillan +conference: ArXiV 1708.09492 +year: 2017 +bibkey: jiang2017automatically +--- +Commit messages are a valuable resource in comprehension of software evolution, since they provide a record of changes such as feature additions and bug repairs. Unfortunately, programmers often neglect to write good commit messages. Different techniques have been proposed to help programmers by automatically writing these messages. These techniques are effective at describing what changed, but are often verbose and lack context for understanding the rationale behind a change. In contrast, humans write messages that are short and summarize the high level rationale. In this paper, we adapt Neural Machine Translation (NMT) to automatically "translate" diffs into commit messages. We trained an NMT algorithm using a corpus of diffs and human-written commit messages from the top 1k Github projects. We designed a filter to help ensure that we only trained the algorithm on higher-quality commit messages. Our evaluation uncovered a pattern in which the messages we generate tend to be either very high or very low quality. Therefore, we created a quality-assurance filter to detect cases in which we are unable to produce good messages, and return a warning instead. diff --git a/_publications/kremenek2007factor.markdown b/_publications/kremenek2007factor.markdown new file mode 100644 index 00000000..c076de84 --- /dev/null +++ b/_publications/kremenek2007factor.markdown @@ -0,0 +1,19 @@ +--- +layout: publication +title: "A Factor Graph Model for Software Bug Finding" +authors: T. Kremenek, A.Y. Ng, D. Engler +conference: IJCAI +year: 2007 +bibkey: kremenek2007factor +--- +Automatic tools for finding software errors require +knowledge of the rules a program must obey, or +“specifications,” before they can identify bugs. We +present a method that combines factor graphs and +static program analysis to automatically infer specifications directly from programs. We illustrate the +approach on inferring functions in C programs that +allocate and release resources, and evaluate the approach on three codebases: SDL, OpenSSH, and +the OS kernel for Mac OS X (XNU). The inferred +specifications are highly accurate and with them we +have discovered numerous bugs. + diff --git a/_publications/levy2017learning.markdown b/_publications/levy2017learning.markdown new file mode 100644 index 00000000..a1ab2cc1 --- /dev/null +++ b/_publications/levy2017learning.markdown @@ -0,0 +1,19 @@ +--- +layout: publication +title: "Learning to Align the Source Code to the Compiled Object Code" +authors: D. Levy, L. Wolf +conference: ICML +year: 2017 +bibkey: levy2017learning +--- +We propose a new neural network architecture +and use it for the task of statement-by-statement +alignment of source code and its compiled object code. Our architecture learns the alignment +between the two sequences – one being the translation of the other – by mapping each statement +to a context-dependent representation vector and +aligning such vectors using a grid of the two sequence domains. Our experiments include short +C functions, both artificial and human-written, +and show that our neural network architecture +is able to predict the alignment with high accuracy, outperforming known baselines. We also +demonstrate that our model is general and can +learn to solve graph problems such as the Traveling Salesman Problem. diff --git a/_publications/li2015gated.markdown b/_publications/li2015gated.markdown new file mode 100644 index 00000000..d49b8882 --- /dev/null +++ b/_publications/li2015gated.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Gated Graph Sequence Neural Networks" +authors: Y. Li, D. Tarlow, M. Brockschmidt, R. Zemel +conference: ICLR +year: 2015 +bibkey: li2015gated +--- +Graph-structured data appears frequently in domains including chemistry, natural language semantics, social networks, and knowledge bases. In this work, we study feature learning techniques for graph-structured inputs. Our starting point is previous work on Graph Neural Networks (Scarselli et al., 2009), which we modify to use gated recurrent units and modern optimization techniques and then extend to output sequences. The result is a flexible and broadly useful class of neural network models that has favorable inductive biases relative to purely sequence-based models (e.g., LSTMs) when the problem is graph-structured. We demonstrate the capabilities on some simple AI (bAbI) and graph algorithm learning tasks. We then show it achieves state-of-the-art performance on a problem from program verification, in which subgraphs need to be matched to abstract data structures. diff --git a/_publications/loyola2017neural.markdown b/_publications/loyola2017neural.markdown new file mode 100644 index 00000000..971a0484 --- /dev/null +++ b/_publications/loyola2017neural.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "A Neural Architecture for Generating Natural Language Descriptions from Source Code Changes" +authors: P. Loyola, E. Marrese-Taylor, Y. Matsuo +conference: ArXiV 1704.04856 +year: 2017 +bibkey: loyola2017neural +--- +We propose a model to automatically describe changes introduced in the source code of a program using natural language. Our method receives as input a set of code commits, which contains both the modifications and message introduced by an user. These two modalities are used to train an encoder-decoder architecture. We evaluated our approach on twelve real world open source projects from four different programming languages. Quantitative and qualitative results showed that the proposed approach can generate feasible and semantically sound descriptions not only in standard in-project settings, but also in a cross-project setting. diff --git a/_publications/mou2016convolutional.markdown b/_publications/mou2016convolutional.markdown new file mode 100644 index 00000000..db38d5c0 --- /dev/null +++ b/_publications/mou2016convolutional.markdown @@ -0,0 +1,16 @@ +--- +layout: publication +title: "Convolutional Neural Networks over Tree Structures for Programming Language Processing" +authors: L. Mou, G. Li, L. Zhang, T. Wang, Z. Jin +conference: AAAI +year: 2016 +bibkey: mou2016convolutional +--- +Programming language processing (similar to natural language processing) is a hot research topic in the field of software engineering; it has also aroused growing interest in the +artificial intelligence community. However, different from a +natural language sentence, a program contains rich, explicit, +and complicated structural information. Hence, traditional +NLP models may be inappropriate for programs. In this paper, we propose a novel tree-based convolutional neural network (TBCNN) for programming language processing, in +which a convolution kernel is designed over programs’ abstract syntax trees to capture structural information. TBCNN +is a generic architecture for programming language processing; our experiments show its effectiveness in two different program analysis tasks: classifying programs according +to functionality, and detecting code snippets of certain patterns. TBCNN outperforms baseline methods, including several neural models for NLP. diff --git a/_publications/murali2017bayesian.markdown b/_publications/murali2017bayesian.markdown new file mode 100644 index 00000000..f3d89f7b --- /dev/null +++ b/_publications/murali2017bayesian.markdown @@ -0,0 +1,28 @@ +--- +layout: publication +title: "Bayesian Sketch Learning for Program Synthesis" +authors: V. Murali, S. Chaudhuri, C. Jermaine +conference: arXiv preprint 1703.05698 +year: 2017 +bibkey: murali2017bayesian +--- +We present a Bayesian statistical approach to the problem of automatic program synthesis. Our synthesizer starts +by learning, offline and from an existing corpus, a probabilistic model of real-world programs. During synthesis, +it is provided some ambiguous and incomplete evidence about the nature of the programming task that the user +wants automated, for example sets of API calls or data types that are relevant for the task. Given this input, the +synthesizer infers a posterior distribution over type-safe programs that assigns higher likelihood to programs +that, according to the learned model, are more likely to match the evidence. + +We realize this approach using two key ideas. First, our learning techniques operate not over code but +syntactic abstractions, or sketches, of programs. During synthesis, we infer a posterior distribution over sketches, +then concretize samples from this distribution into type-safe programs using combinatorial techniques. Second, +our statistical model explicitly models the full intent behind a synthesis task as a latent variable. To infer +sketches, we first estimate a posterior distribution on the intent, then use samples from this posterior to generate +a distribution over possible sketches. We show that our model can be implemented effectively using the new +neural architecture of Bayesian encoder-decoders, which can be trained with stochastic gradient descent and +yields a simple inference procedure. + +We implement our ideas in a system, called BAYOU , for the synthesis of API-heavy Java methods. We train +BAYOU on a large corpus of Android apps, and find that the trained system can often synthesize complex +methods given just a few API method names or data types as evidence. The experiments also justify the design +choice of using a latent intent variable and the levels of abstraction at which sketches and evidence are defined. diff --git a/_publications/murali2017finding.markdown b/_publications/murali2017finding.markdown new file mode 100644 index 00000000..f1707ff1 --- /dev/null +++ b/_publications/murali2017finding.markdown @@ -0,0 +1,29 @@ +--- +layout: publication +title: "Finding Likely Errors with Bayesian Specifications" +authors: V. Murali, S. Chaudhuri, C. Jermaine +conference: arXiv preprint 1703.01370 +year: 2017 +bibkey: murali2017finding +--- +We present a Bayesian framework for learning probabilistic specifications from large, unstructured code corpora, and +a method to use this framework to statically detect anomalous, hence likely buggy, program behavior. The distinctive +insight here is to build a statistical model that correlates all +specifications hidden inside a corpus with the syntax and +observed behavior of programs that implement these specifications. During the analysis of a particular program, this +model is conditioned into a posterior distribution that prioritizes specifications that are relevant to this program. This +allows accurate program analysis even if the corpus is highly +heterogeneous. The problem of finding anomalies is now +framed quantitatively, as a problem of computing a distance +between a “reference distribution” over program behaviors +that our model expects from the program, and the distribution over behaviors that the program actually produces. + +We present a concrete embodiment of our framework that +combines a topic model and a neural network model to learn +specifications, and queries the learned models to compute +anomaly scores. We evaluate this implementation on the +task of detecting anomalous usage of Android APIs. Our +encouraging experimental results show that the method can +automatically discover subtle errors in Android applications +in the wild, and has high precision and recall compared to +competing probabilistic approaches. diff --git a/_publications/rabinovich2017abstract.markdown b/_publications/rabinovich2017abstract.markdown new file mode 100644 index 00000000..7e1b7271 --- /dev/null +++ b/_publications/rabinovich2017abstract.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Abstract Syntax Networks for Code Generation and Semantic Parsing" +authors: M. Rabinovich, M. Stern, D. Klein +conference: ACL +year: 2017 +bibkey: rabinovich2017abstract +--- +Tasks like code generation and semantic parsing require mapping unstructured (or partially structured) inputs to well-formed, executable outputs. We introduce abstract syntax networks, a modeling framework for these problems. The outputs are represented as abstract syntax trees (ASTs) and constructed by a decoder with a dynamically-determined modular structure paralleling the structure of the output tree. On the benchmark Hearthstone dataset for code generation, our model obtains 79.2 BLEU and 22.7% exact match accuracy, compared to previous state-of-the-art values of 67.1 and 6.1%. Furthermore, we perform competitively on the Atis, Jobs, and Geo semantic parsing datasets with no task-specific engineering. diff --git a/_publications/wang2016bugram.markdown b/_publications/wang2016bugram.markdown new file mode 100644 index 00000000..22ad5948 --- /dev/null +++ b/_publications/wang2016bugram.markdown @@ -0,0 +1,16 @@ +--- +layout: publication +title: "Bugram: bug detection with n-gram language models" +authors: S. Wang, D. Chollak, D. Movshovitz-Attias, L. Tan +conference: ASE +year: 2016 +bibkey: wang2016bugram +--- + +To improve software reliability, many rule-based techniques have been proposed to infer programming rules and detect violations of these rules as bugs. These rule-based approaches often rely on the highly frequent appearances of certain patterns in a project to infer rules. It is known that if a pattern does not appear frequently enough, rules are not learned, thus missing many bugs. + +In this paper, we propose a new approach—Bugram—that leverages n-gram language models instead of rules to detect bugs. Bugram models program tokens sequentially, using the n-gram language model. Token sequences from the program are then assessed according to their probability in the learned model, and low probability sequences are marked as potential bugs. The assumption is that low probability token sequences in a program are unusual, which may indicate bugs, bad practices, or unusual/special uses of code of which developers may want to be aware. + +We evaluate Bugram in two ways. First, we apply Bugram on the latest versions of 16 open source Java projects. Results show that Bugram detects 59 bugs, 42 of which are manually verified as correct, 25 of which are true bugs and 17 are code snippets that should be refactored. Among the 25 true bugs, 23 cannot be detected by PR-Miner. We have reported these bugs to developers, 7 of which have already been confirmed by developers (4 of them have already been fixed), while the rest await confirmation. Second, we further compare Bugram with three additional graph- and rule-based bug detection tools, i.e., JADET, Tikanga, and GrouMiner. We apply Bugram on 14 Java projects evaluated in these three studies. Bugram detects 21 true bugs, at least 10 of which cannot be detected by these three tools. Our results suggest that Bugram is complementary to existing rule-based bug detection approaches. + + diff --git a/_publications/zaremba2014learning.markdown b/_publications/zaremba2014learning.markdown new file mode 100644 index 00000000..0cf4ae9d --- /dev/null +++ b/_publications/zaremba2014learning.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Learning to Execute" +authors: W. Zaremba, I. Sutskever +conference: ArXiV 1410.4615 +year: 2014 +bibkey: zaremba2014learning +--- +Recurrent Neural Networks (RNNs) with Long Short-Term Memory units (LSTM) are widely used because they are expressive and are easy to train. Our interest lies in empirically evaluating the expressiveness and the learnability of LSTMs in the sequence-to-sequence regime by training them to evaluate short computer programs, a domain that has traditionally been seen as too complex for neural networks. We consider a simple class of programs that can be evaluated with a single left-to-right pass using constant memory. Our main result is that LSTMs can learn to map the character-level representations of such programs to their correct outputs. Notably, it was necessary to use curriculum learning, and while conventional curriculum learning proved ineffective, we developed a new variant of curriculum learning that improved our networks' performance in all experimental conditions. The improved curriculum had a dramatic impact on an addition problem, making it possible to train an LSTM to add two 9-digit numbers with 99% accuracy. From 1f510233fa83d84c3160c9d90902365dcc6a646f Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sun, 17 Sep 2017 00:17:49 +0100 Subject: [PATCH 21/98] remove unused files. --- LICENSE.md | 9 ---- README.md | 134 ----------------------------------------------------- atom.xml | 28 ----------- 3 files changed, 171 deletions(-) delete mode 100644 LICENSE.md delete mode 100644 README.md delete mode 100644 atom.xml diff --git a/LICENSE.md b/LICENSE.md deleted file mode 100644 index af1b0ec7..00000000 --- a/LICENSE.md +++ /dev/null @@ -1,9 +0,0 @@ -# Released under MIT License - -Copyright (c) 2014 Mark Otto. - -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md deleted file mode 100644 index b6c7d402..00000000 --- a/README.md +++ /dev/null @@ -1,134 +0,0 @@ -# Lanyon - -Lanyon is an unassuming [Jekyll](http://jekyllrb.com) theme that places content first by tucking away navigation in a hidden drawer. It's based on [Poole](http://getpoole.com), the Jekyll butler. - -![Lanyon](https://f.cloud.github.com/assets/98681/1825266/be03f014-71b0-11e3-9539-876e61530e24.png) -![Lanyon with open sidebar](https://f.cloud.github.com/assets/98681/1825267/be04a914-71b0-11e3-966f-8afe9894c729.png) - - -## Contents - -- [Usage](#usage) -- [Options](#options) - - [Sidebar menu](#sidebar-menu) - - [Themes](#themes) - - [Reverse layout](#reverse-layout) -- [Development](#development) -- [Author](#author) -- [License](#license) - - -## Usage - -Lanyon is a theme built on top of [Poole](https://github.com/poole/poole), which provides a fully furnished Jekyll setup—just download and start the Jekyll server. See [the Poole usage guidelines](https://github.com/poole/poole#usage) for how to install and use Jekyll. - - -## Options - -Lanyon includes some customizable options, typically applied via classes on the `` element. - - -### Sidebar menu - -Create a list of nav links in the sidebar by assigning each Jekyll page the correct layout in the page's [front-matter](http://jekyllrb.com/docs/frontmatter/). - -``` ---- -layout: page -title: About ---- -``` - -**Why require a specific layout?** Jekyll will return *all* pages, including the `atom.xml`, and with an alphabetical sort order. To ensure the first link is *Home*, we exclude the `index.html` page from this list by specifying the `page` layout. - - -### Themes - -Lanyon ships with eight optional themes based on the [base16 color scheme](https://github.com/chriskempson/base16). Apply a theme to change the color scheme (mostly applies to sidebar and links). - -![Lanyon with red theme](https://f.cloud.github.com/assets/98681/1825270/be065110-71b0-11e3-9ed8-9b8de753a4af.png) -![Lanyon with red theme and open sidebar](https://f.cloud.github.com/assets/98681/1825269/be05ec20-71b0-11e3-91ea-a9138ef07186.png) - -There are eight themes available at this time. - -![Available theme classes](https://f.cloud.github.com/assets/98681/1817044/e5b0ec06-6f68-11e3-83d7-acd1942797a1.png) - -To use a theme, add any one of the available theme classes to the `` element in the `default.html` layout, like so: - -```html - - ... - -``` - -To create your own theme, look to the Themes section of [included CSS file](https://github.com/poole/lanyon/blob/master/public/css/lanyon.css). Copy any existing theme (they're only a few lines of CSS), rename it, and change the provided colors. - - -### Reverse layout - -![Lanyon with reverse layout](https://f.cloud.github.com/assets/98681/1825265/be03f2e4-71b0-11e3-89f1-360705524495.png) -![Lanyon with reverse layout and open sidebar](https://f.cloud.github.com/assets/98681/1825268/be056174-71b0-11e3-88c8-5055bca4307f.png) - -Reverse the page orientation with a single class. - -```html - - ... - -``` - - -### Sidebar overlay instead of push - -Make the sidebar overlap the viewport content with a single class: - -```html - - ... - -``` - -This will keep the content stationary and slide in the sidebar over the side content. It also adds a `box-shadow` based outline to the toggle for contrast against backgrounds, as well as a `box-shadow` on the sidebar for depth. - -It's also available for a reversed layout when you add both classes: - -```html - - ... - -``` - -### Sidebar open on page load - -Show an open sidebar on page load by modifying the `` tag within the `sidebar.html` layout to add the `checked` boolean attribute: - -```html - -``` - -Using Liquid you can also conditionally show the sidebar open on a per-page basis. For example, here's how you could have it open on the homepage only: - -```html - -``` - -## Development - -Lanyon has two branches, but only one is used for active development. - -- `master` for development. **All pull requests should be to submitted against `master`.** -- `gh-pages` for our hosted site, which includes our analytics tracking code. **Please avoid using this branch.** - - -## Author - -**Mark Otto** -- -- - - -## License - -Open sourced under the [MIT license](LICENSE.md). - -<3 diff --git a/atom.xml b/atom.xml deleted file mode 100644 index 96c9681c..00000000 --- a/atom.xml +++ /dev/null @@ -1,28 +0,0 @@ ---- -layout: null ---- - - - - - {{ site.title }} - - - {{ site.time | date_to_xmlschema }} - {{ site.url }} - - {{ site.author.name }} - {{ site.author.email }} - - - {% for post in site.posts %} - - {{ post.title }} - - {{ post.date | date_to_xmlschema }} - {{ site.url }}{{ post.id }} - {{ post.content | xml_escape }} - - {% endfor %} - - From 6ff6b516bf8e3de1b787e9e4a413985cec471c23 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sun, 17 Sep 2017 00:56:28 +0100 Subject: [PATCH 22/98] Last batch of publications. --- _publications/amodio2017neural.markdown | 2 +- _publications/barone2017parallel.markdown | 15 +++++++++ .../beltramelli2017pix2code.markdown | 10 ++++++ _publications/bhoopchand2016learning.markdown | 9 +++++ .../cummins2017synthesizing.markdown | 9 +++++ _publications/gvero2015synthesizing.markdown | 9 +++++ _publications/kushman2013using.markdown | 9 +++++ _publications/lin2017program.markdown | 33 +++++++++++++++++++ _publications/menon2013machine.markdown | 22 +++++++++++++ _publications/patra2016learning.markdown | 22 +++++++++++++ _publications/pham2016learning.markdown | 9 +++++ _publications/pu2016skp.markdown | 13 ++++++++ _publications/wang2016neural.markdown | 19 +++++++++++ 13 files changed, 180 insertions(+), 1 deletion(-) create mode 100644 _publications/barone2017parallel.markdown create mode 100644 _publications/beltramelli2017pix2code.markdown create mode 100644 _publications/bhoopchand2016learning.markdown create mode 100644 _publications/cummins2017synthesizing.markdown create mode 100644 _publications/gvero2015synthesizing.markdown create mode 100644 _publications/kushman2013using.markdown create mode 100644 _publications/lin2017program.markdown create mode 100644 _publications/menon2013machine.markdown create mode 100644 _publications/patra2016learning.markdown create mode 100644 _publications/pham2016learning.markdown create mode 100644 _publications/pu2016skp.markdown create mode 100644 _publications/wang2016neural.markdown diff --git a/_publications/amodio2017neural.markdown b/_publications/amodio2017neural.markdown index 0b081f37..ea636ea3 100644 --- a/_publications/amodio2017neural.markdown +++ b/_publications/amodio2017neural.markdown @@ -4,7 +4,7 @@ title: "Neural Attribute Machines for Program Generation" authors: M. Amodio, S. Chaudhuri, T. Reps conference: year: 2017 -bibkey: amodio2016neural +bibkey: amodio2017neural --- Recurrent neural networks have achieved remarkable success at generating sequences with complex structures, thanks to advances that include richer embeddings of input and cures for vanishing gradients. Trained only on sequences from a known grammar, though, they can still struggle to learn rules and constraints of the grammar. Neural Attribute Machines (NAMs) are equipped with a logical machine that represents the underlying grammar, which is used to teach the constraints to the neural machine by (i) augmenting the input sequence, and (ii) optimizing a custom loss function. Unlike traditional RNNs, NAMs are exposed to the grammar, as well as samples from the language of the grammar. During generation, NAMs make significantly fewer violations of the constraints of the underlying grammar than RNNs trained only on samples from the language of the grammar. diff --git a/_publications/barone2017parallel.markdown b/_publications/barone2017parallel.markdown new file mode 100644 index 00000000..5aa88364 --- /dev/null +++ b/_publications/barone2017parallel.markdown @@ -0,0 +1,15 @@ +--- +layout: publication +title: "A parallel corpus of Python functions and documentation strings for automated code documentation and code generation" +authors: A.V.M. Barone, R. Sennrich +conference: ArXiV 1707.02275 +year: 2017 +bibkey: barone2017parallel +--- +Automated documentation of programming source code and automated code generation from natural language are challenging tasks of both practical and scientific interest. Progress in these areas has been limited by the low availability of parallel corpora of code and natural language descriptions, which tend to be small and constrained to specific domains. + +In this work we introduce a large and diverse parallel corpus of a hundred thousands Python functions with their documentation strings ("docstrings") generated by scraping open source repositories on GitHub. We describe baseline results for the code documentation and code generation tasks obtained by neural machine translation. We also experiment with +data augmentation techniques to further increase the amount of training data. + +We release our datasets and processing scripts in order to stimulate research in these areas. + diff --git a/_publications/beltramelli2017pix2code.markdown b/_publications/beltramelli2017pix2code.markdown new file mode 100644 index 00000000..68bd867f --- /dev/null +++ b/_publications/beltramelli2017pix2code.markdown @@ -0,0 +1,10 @@ +--- +layout: publication +title: "pix2code: Generating Code from a Graphical User Interface Screenshot" +authors: T. Beltramelli +conference: ArXiV 1705.07962 +year: 2017 +bibkey: beltramelli2017pix2code +--- +Transforming a graphical user interface screenshot created by a designer into computer code is a typical task conducted by a developer in order to build customized software, websites and mobile applications. In this paper, we show that Deep Learning techniques can be leveraged to automatically generate code given a graphical user interface screenshot as input. Our model is able to generate code targeting three different platforms (i.e. iOS, Android and web-based technologies) from a single input image with over 77% of accuracy. + diff --git a/_publications/bhoopchand2016learning.markdown b/_publications/bhoopchand2016learning.markdown new file mode 100644 index 00000000..371d4d22 --- /dev/null +++ b/_publications/bhoopchand2016learning.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Learning Python Code Suggestion with a Sparse Pointer Network" +authors: A. Bhoopchand, T. Rocktäschel, E.T. Barr, S. Riedel +conference: ArXiV 1611.08307 +year: 2016 +bibkey: bhoopchand2016learning +--- +To enhance developer productivity, all modern integrated development environments (IDEs) include code suggestion functionality that proposes likely next tokens at the cursor. While current IDEs work well for statically-typed languages, their reliance on type annotations means that they do not provide the same level of support for dynamic programming languages as for statically-typed languages. Moreover, suggestion engines in modern IDEs do not propose expressions or multi-statement idiomatic code. Recent work has shown that language models can improve code suggestion systems by learning from software repositories. This paper introduces a neural language model with a sparse pointer network aimed at capturing very long-range dependencies. We release a large-scale code suggestion corpus of 41M lines of Python code crawled from GitHub. On this corpus, we found standard neural language models to perform well at suggesting local phenomena, but struggle to refer to identifiers that are introduced many tokens in the past. By augmenting a neural language model with a pointer network specialized in referring to predefined classes of identifiers, we obtain a much lower perplexity and a 5 percentage points increase in accuracy for code suggestion compared to an LSTM baseline. In fact, this increase in code suggestion accuracy is due to a 13 times more accurate prediction of identifiers. Furthermore, a qualitative analysis shows this model indeed captures interesting long-range dependencies, like referring to a class member defined over 60 tokens in the past. diff --git a/_publications/cummins2017synthesizing.markdown b/_publications/cummins2017synthesizing.markdown new file mode 100644 index 00000000..a079b407 --- /dev/null +++ b/_publications/cummins2017synthesizing.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Synthesizing benchmarks for predictive modeling" +authors: C. Cummin, P. Petoumenos, Z. Wang, H. Leather +conference: CGO +year: 2017 +bibkey: cummins2017synthesizing +--- +Predictive modeling using machine learning is an effective method for building compiler heuristics, but there is a shortage of benchmarks. Typical machine learning experiments outside of the compilation field train over thousands or millions of examples. In machine learning for compilers, however, there are typically only a few dozen common benchmarks available. This limits the quality of learned models, as they have very sparse training data for what are often high-dimensional feature spaces. What is needed is a way to generate an unbounded number of training programs that finely cover the feature space. At the same time the generated programs must be similar to the types of programs that human developers actually write, otherwise the learning will target the wrong parts of the feature space. We mine open source repositories for program fragments and apply deep learning techniques to automatically construct models for how humans write programs. We sample these models to generate an unbounded number of runnable training programs. The quality of the programs is such that even human developers struggle to distinguish our generated programs from hand-written code. We use our generator for OpenCL programs, CLgen, to automatically synthesize thousands of programs and show that learning over these improves the performance of a state of the art predictive model by 1.27x. In addition, the fine covering of the feature space automatically exposes weaknesses in the feature design which are invisible with the sparse training examples from existing benchmark suites. Correcting these weaknesses further increases performance by 4.30x. diff --git a/_publications/gvero2015synthesizing.markdown b/_publications/gvero2015synthesizing.markdown new file mode 100644 index 00000000..e002e91c --- /dev/null +++ b/_publications/gvero2015synthesizing.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Synthesizing Java expressions from free-form queries" +authors: T. Gvero, V. Kuncak +conference: OOPSLA +year: 2015 +bibkey: gvero2015synthesizing +--- +We present a new code assistance tool for integrated development environments. Our system accepts as input free-form queries containing a mixture of English and Java, and produces Java code expressions that take the query into account and respect syntax, types, and scoping rules of Java, as well as statistical usage patterns. In contrast to solutions based on code search, the results returned by our tool need not directly correspond to any previously seen code fragment. As part of our system we have constructed a probabilistic context free grammar for Java constructs and library invocations, as well as an algorithm that uses a customized natural language processing tool chain to extract information from free-form text queries. We present the results on a number of examples showing that our technique (1) often produces the expected code fragments, (2) tolerates much of the flexibility of natural language, and (3) can repair incorrect Java expressions that use, for example, the wrong syntax or missing arguments. diff --git a/_publications/kushman2013using.markdown b/_publications/kushman2013using.markdown new file mode 100644 index 00000000..613649db --- /dev/null +++ b/_publications/kushman2013using.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Using Semantic Unification to Generate Regular Expressions from Natural Language" +authors: N. Kushman, R. Barzilay +conference: NAACL +year: 2013 +bibkey: kushman2013using +--- +We consider the problem of translating natural language text queries into regular expressions which represent their meaning. The mismatch in the level of abstraction between the natural language representation and the regular expression representation make this a novel and challenging problem. However, a given regular expression can be written in many semantically equivalent forms, and we exploit this flexibility to facilitate translation by finding a form which more directly corresponds to the natural language. We evaluate our technique on a set of natural language queries and their associated regular expressions which we gathered from Amazon Mechanical Turk. Our model substantially outperforms a state-of-the-art semantic parsing baseline, yielding a 29% absolute improvement in accuracy. diff --git a/_publications/lin2017program.markdown b/_publications/lin2017program.markdown new file mode 100644 index 00000000..825584ac --- /dev/null +++ b/_publications/lin2017program.markdown @@ -0,0 +1,33 @@ +--- +layout: publication +title: "Program Synthesis from Natural Language Using Recurrent Neural Networks" +authors: X.V. Lin, C. Wang, D. Pang, K. Vu, L. Zettlemoyer, M.D. Ernst +conference: Technical Report UW-CSE-17-03-01, University of Washington Department of Computer Science and Engineering +year: 2017 +bibkey: lin2017program +--- +Oftentimes, a programmer may have difficulty implementing a +desired operation. Even when the programmer can describe her +goal in English, it can be difficult to translate into code. Existing +resources, such as question-and-answer websites, tabulate specific +operations that someone has wanted to perform in the past, but +they are not effective in generalizing to new tasks, to compound +tasks that require combining previous questions, or sometimes even +to variations of listed tasks. + +Our goal is to make programming easier and more productive by +letting programmers use their own words and concepts to express +the intended operation, rather than forcing them to accommodate +the machine by memorizing its grammar. We have built a system +that lets a programmer describe a desired operation in natural language, then automatically translates it to a programming language +for review and approval by the programmer. Our system, Tellina, +does the translation using recurrent neural networks (RNNs), a +state-of-the-art natural language processing technique that we augmented with slot (argument) filling and other enhancements. + +We evaluated Tellina in the context of shell scripting. We trained +Tellina’s RNNs on textual descriptions of file system operations +and bash one-liners, scraped from the web. Although recovering +completely correct commands is challenging, Tellina achieves top-3 +accuracy of 80% for producing the correct command structure. In a +controlled study, programmers who had access to Tellina outperformed those who did not, even when Tellina’s predictions were +not completely correct, to a statistically significant degree. diff --git a/_publications/menon2013machine.markdown b/_publications/menon2013machine.markdown new file mode 100644 index 00000000..c3558560 --- /dev/null +++ b/_publications/menon2013machine.markdown @@ -0,0 +1,22 @@ +--- +layout: publication +title: "A Machine Learning Framework for Programming by Example" +authors: A. K. Menon, O. Tamuz, S. Gulwani, B. Lampson, A.T. Kalai +conference: ICML +year: 2013 +bibkey: menon2013machine +--- +Learning programs is a timely and interesting challenge. In Programming by Example +(PBE), a system attempts to infer a program +from input and output examples alone, by +searching for a composition of some set of +base functions. We show how machine learning can be used to speed up this seemingly +hopeless search problem, by learning weights +that relate textual features describing the +provided input-output examples to plausible +sub-components of a program. This generic +learning framework lets us address problems +beyond the scope of earlier PBE systems. +Experiments on a prototype implementation +show that learning improves search and ranking on a variety of text processing tasks found +on help forums. diff --git a/_publications/patra2016learning.markdown b/_publications/patra2016learning.markdown new file mode 100644 index 00000000..face1f24 --- /dev/null +++ b/_publications/patra2016learning.markdown @@ -0,0 +1,22 @@ +--- +layout: publication +title: "Learning to Fuzz: Application-Independent Fuzz Testing with Probabilistic, Generative Models of Input Data" +authors: J. Patra, M. Pradel +conference: +year: 2016 +bibkey: patra2016learning +--- +Fuzzing is a popular technique to create test inputs for software that processes structured data. It has been successfully +applied in various domains, ranging from compilers and interpreters over program analyses to rendering engines, image manipulation tools, and word processors. Existing fuzz +testing techniques are tailored for a particular purpose and +rely on a carefully crafted model of the data to be generated. +This paper presents TreeFuzz, a generic approach for generating structured data without an a priori known model. The +key idea is to exploit a given corpus of example data to au- +tomatically infer probabilistic, generative models that create +new data with properties similar to the corpus. To support a +wide range of different properties, TreeFuzz is designed as a +framework with an extensible set of techniques to infer generative models. We apply the idea to JavaScript programs +and HTML documents and show that the approach generates mostly valid data for both of them: 96.3% of the generated JavaScript programs are syntactically valid and there are +only 2.06 validation errors per kilobyte of generated HTML. +The performance of both learning and generation scales linearly w.r.t. the size of the corpus. Using TreeFuzz-generated +JavaScript programs for differential testing of JavaScript engines exposes various inconsistencies among browsers, including browser bugs and unimplemented language features. diff --git a/_publications/pham2016learning.markdown b/_publications/pham2016learning.markdown new file mode 100644 index 00000000..5626db64 --- /dev/null +++ b/_publications/pham2016learning.markdown @@ -0,0 +1,9 @@ +--- +layout: publication +title: "Learning API usages from bytecode: a statistical approach." +authors: H.V. Pham, T.T. Nguyen, P.M. Vu, T.T. Nguyen +conference: ICSE +year: 2016 +bibkey: pham2016learning +--- +Mobile app developers rely heavily on standard API frameworks and libraries. However, learning API usages is often challenging due to the fast-changing nature of API frameworks for mobile systems and the insufficiency of API documentation and source code examples. In this paper, we propose a novel approach to learn API usages from bytecode of Android mobile apps. Our core contributions include HAPI, a statistical model of API usages and three algorithms to extract method call sequences from apps' bytecode, to train HAPI based on those sequences, and to recommend method calls in code completion using the trained HAPIs. Our empirical evaluation shows that our prototype tool can effectively learn API usages from 200 thousand apps containing 350 million method sequences. It recommends next method calls with top-3 accuracy of 90% and outperforms baseline approaches on average 10-20%. diff --git a/_publications/pu2016skp.markdown b/_publications/pu2016skp.markdown new file mode 100644 index 00000000..147af5d3 --- /dev/null +++ b/_publications/pu2016skp.markdown @@ -0,0 +1,13 @@ +--- +layout: publication +title: "sk_p: a neural program corrector for MOOCs" +authors: Y. Pu, K. Narasimhan, A. Solar-Lezama, R. Barzilay +conference: SPLASH +year: 2016 +bibkey: pu2016skp +--- +We present a novel technique for automatic program correction in MOOCs, capable of fixing both syntactic and semantic errors without manual, problem specific correction strategies. Given an incorrect student program, it generates candidate programs from a distribution of likely corrections, and checks each candidate for correctness against a test suite. + +The key observation is that in MOOCs many programs share similar code fragments, and the seq2seq neural network model, used in the natural-language processing task of machine translation, can be modified and trained to recover these fragments. + +Experiment shows our scheme can correct 29% of all incorrect submissions and out-performs state of the art approach which requires manual, problem specific correction strategies. diff --git a/_publications/wang2016neural.markdown b/_publications/wang2016neural.markdown new file mode 100644 index 00000000..3947f0a6 --- /dev/null +++ b/_publications/wang2016neural.markdown @@ -0,0 +1,19 @@ +--- +layout: publication +title: "Neural Code Completion" +authors: C. Liu, X. Wang, R. Shin, J.E. Gonzalez, D. Song +conference: +year: 2016 +bibkey: wang2016neural +--- +Code completion, an essential part of modern software development, yet can be +challenging for dynamically typed programming languages. In this paper we explore the use of neural network techniques to automatically learn code completion +from a large corpus of dynamically typed JavaScript code. We show different +neural networks that leverage not only token level information but also structural +information, and evaluate their performance on different prediction tasks. We +demonstrate that our models can outperform the state-of-the-art approach, which +is based on decision tree techniques, on both next non-terminal and next terminal +prediction tasks by 3.8 points and 0.5 points respectively. We believe that neural +network techniques can play a transformative role in helping software developers +manage the growing complexity of software systems, and we see this work as a +first step in that direction. From 35a3fd3bb61f1858039523c6c2367243690c3ff4 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sun, 17 Sep 2017 20:38:27 +0100 Subject: [PATCH 23/98] Fixes. --- _config.yml | 4 ++-- _includes/sidebar.html | 8 +++----- _publications/omar2013structured.markdown | 2 +- contributing.markdown | 15 ++++++++------- index.md | 23 ++++++++++++++++------- papers.html | 2 +- 6 files changed, 31 insertions(+), 23 deletions(-) diff --git a/_config.yml b/_config.yml index 937868b3..e12e031d 100644 --- a/_config.yml +++ b/_config.yml @@ -1,6 +1,6 @@ # Setup -title: Probabilistic Models of Code -tagline: 'a literature review' +title: Machine Learning for Big Code and Naturalness +tagline: 'a survey' description: 'A survey of academic research on machine learning models for source code.' url: http://todo.com baseurl: '' diff --git a/_includes/sidebar.html b/_includes/sidebar.html index 9dd56b0b..cdda6c84 100644 --- a/_includes/sidebar.html +++ b/_includes/sidebar.html @@ -2,7 +2,7 @@

    - + {{ site.title }}

    @@ -10,8 +10,6 @@

    -

    - Powered by Jekyll and Lanyon. +

    + Made with Jekyll and Lanyon.

    diff --git a/_publications/omar2013structured.markdown b/_publications/omar2013structured.markdown index f0734b8b..4216f951 100644 --- a/_publications/omar2013structured.markdown +++ b/_publications/omar2013structured.markdown @@ -1,7 +1,7 @@ --- layout: publication title: "Structured Statistical Syntax Tree Prediction" -authors: C.Omar +authors: C. Omar conference: SPLASH year: 2013 bibkey: omar2013structured diff --git a/contributing.markdown b/contributing.markdown index f55cd9d8..5b63a5da 100644 --- a/contributing.markdown +++ b/contributing.markdown @@ -5,7 +5,7 @@ title: Contributing Contributions of new or missing publications are very welcome. Alternative categorization/taxonomies can also be added to the website. To contribute, please open a pull request [here](https://github.com/ml4code/ml4code.github.io), but first please read the instructions below. -## Adding a publication +### Adding a publication To add a publication (new or missing), create a file in the `_publications` folder. The name of the file should follow the structure `lastnameYEARfirstword.markdown` where `lastname` is the last name of the first author and `firstword` is the first non-punctuation word of the work's title. Within each file, follow the structure shown in the other files. Once the file is added, the work will appear in the "All Papers" section. 
     ---
@@ -23,13 +23,14 @@ additional_links:
 text-of-abstract
    -The `additional_links` are optional and arbitrary and they will appear on the page refering to this work. Feel free to add as many additional links as needed. +The `additional_links` are optional and arbitrary and they will appear on the page referring to this work. Feel free to add as many additional links as needed. -## Adding a new categorization -No single taxonomy or categorization can fit everyone. It is easy to contribute a new categorization to be shown in this website. TODO TODO +### Adding a new categorization +No single taxonomy or categorization can fit everyone. It is easy to contribute a new categorization to be shown in this website. First, create a data file, similar to those in the `_data` file describing your taxonomy. +This can be a JSON, YAML or CSV file as described [here](https://jekyllrb.com/docs/datafiles/). +Then, create a folder and a page (or pages) that describe your taxonomy. Finally, submit a pull +request to get this merged into the website. -Add a data file describing your hierarchy. This can be a JSON, YAML or CSV file as described [here](https://jekyllrb.com/docs/datafiles/). - -## Reusing the website structure +### Reusing the website structure In principle, the structure of this website can be used for other literature reviews. Feel free to clone it! diff --git a/index.md b/index.md index 6062016c..91310dde 100644 --- a/index.md +++ b/index.md @@ -1,21 +1,30 @@ --- -layout: page -title: About the Survey +layout: default +title: A Survey of Machine Learning for Big Code and Naturalness --- +Research at the intersection of machine learning, programming language, and +software engineering has recently taken important steps in proposing learnable +probabilistic models of source code that exploit code's abundance of patterns. +This website and the accompanying article surveys this work. -Intro about ml 4 code +Like writing and speaking, software development is a human language act. +At its core, +the naturalness of software employs statistical modeling over big code to +reason about rich variety of programs developers write. This new line of +research is inherently interdisciplinary, uniting the machine learning and +natural language processing communities with software engineering +and programming language communities. We present a [taxonomy](\taxnomomy) +based on the underlying design principles of each model and use it to navigate +the literature. The full survey text can be found [here](). -## The survey -Link to paper Please cite as 
     TODO
    - Regarding this review or website, please contact [Miltos Allamanis](https://miltos.allamanis.com). -## Contributing +### Contributing We understand that this is an area that is evolving fast and a static review cannot reflect the continuous evolution of the area. But a website can! We hope to make this site a living document. To contribute, open a pull request in GitHub. Please, read the instructions [here](contributing.html). diff --git a/papers.html b/papers.html index eae208f7..a997e4e0 100644 --- a/papers.html +++ b/papers.html @@ -2,7 +2,7 @@ layout: default title: Home --- - +Below there is a list of related papers within this area, sorted by year. {% assign publicationsByYear = site.publications | sort: "year" | group_by: "year" %} {% for year in publicationsByYear reversed %}

    {{ year.name }}

    From 63d4ce284fa60bf716382bd8b16d23d092e9a839 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Mon, 18 Sep 2017 21:17:05 +0100 Subject: [PATCH 24/98] Add url --- _config.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_config.yml b/_config.yml index e12e031d..e9f7ad1c 100644 --- a/_config.yml +++ b/_config.yml @@ -2,7 +2,7 @@ title: Machine Learning for Big Code and Naturalness tagline: 'a survey' description: 'A survey of academic research on machine learning models for source code.' -url: http://todo.com +url: https://ml4code.github.io baseurl: '' collections: From d628cd16cd77a26d265edb121a1d4440c27977f2 Mon Sep 17 00:00:00 2001 From: Charles Sutton Date: Tue, 19 Sep 2017 00:36:25 +0100 Subject: [PATCH 25/98] intro page --- index.md | 31 ++++++++++++++++++++++--------- 1 file changed, 22 insertions(+), 9 deletions(-) diff --git a/index.md b/index.md index 91310dde..943312df 100644 --- a/index.md +++ b/index.md @@ -2,22 +2,31 @@ layout: default title: A Survey of Machine Learning for Big Code and Naturalness --- -Research at the intersection of machine learning, programming language, and -software engineering has recently taken important steps in proposing learnable -probabilistic models of source code that exploit code's abundance of patterns. -This website and the accompanying article surveys this work. -Like writing and speaking, software development is a human language act. +The billions of lines of source code that have been written contain +implicit knowledge about how to write good code, code that is +easy to read and to debug. +A recent line of research aims to find statistical patterns in large +corpora of code to drive new software development tools and program +analyses. + +This website and the accompanying article surveys the work in this emerging area. + +Like writing and speaking, software development is an act of human communication. + At its core, the naturalness of software employs statistical modeling over big code to reason about rich variety of programs developers write. This new line of research is inherently interdisciplinary, uniting the machine learning and natural language processing communities with software engineering -and programming language communities. We present a [taxonomy](\taxnomomy) -based on the underlying design principles of each model and use it to navigate -the literature. The full survey text can be found [here](). +and programming language communities. +This site is an experiment: a living literature review that allows +you explore the navigate the literautre in this area, by +following a [taxonomy](\taxnomomy) +based on the underlying design principles of each model. +The full survey is available [as a research paper](). Please cite as 
     TODO
@@ -26,5 +35,9 @@ Regarding this review or website, please contact [Miltos Allamanis](https://milt
 
 ### Contributing
 
-We understand that this is an area that is evolving fast and a static review cannot reflect the continuous evolution of the area. But a website can! We hope to make this site a living document. To contribute, open a pull request in GitHub. Please, read the instructions [here](contributing.html).
+This research area is evolving so fast that a static review cannot keep up.
+But a website can! We hope to make this site a living document.
+Anyone can add a paper to this web site, essentially by creating one Markdown file.
+ To contribute, open a pull request in GitHub, by following [these instructions 
+for contributing](contributing.html).
 

From c32b55cb965a7348537e7d51fa3de37de44273f7 Mon Sep 17 00:00:00 2001
From: Miltos Allamanis 
Date: Tue, 19 Sep 2017 20:41:01 +0100
Subject: [PATCH 26/98] Multiple changes, refinments, corrections additions.

---
 README.md                                      |  5 +++++
 _includes/sidebar.html                         | 10 +++++++---
 _publications/allamanis2013mining.markdown     |  1 +
 _publications/allamanis2014learning.markdown   |  1 +
 _publications/allamanis2014mining.markdown     |  1 +
 _publications/allamanis2015suggesting.markdown |  1 +
 base-taxonomy/generative.html                  |  4 ++++
 base-taxonomy/index.md                         |  2 +-
 base-taxonomy/pattern.html                     |  4 ++++
 base-taxonomy/representational.html            |  5 +++++
 contributors.md                                | 18 ++++++++++++++++++
 index.md                                       |  3 +--
 public/css/hyde.css                            |  5 +++++
 public/css/lanyon.css                          |  1 +
 14 files changed, 55 insertions(+), 6 deletions(-)
 create mode 100644 README.md
 create mode 100644 contributors.md

diff --git a/README.md b/README.md
new file mode 100644
index 00000000..54ddc223
--- /dev/null
+++ b/README.md
@@ -0,0 +1,5 @@
+Machine Learning for Big Code and Naturalness
+###
+This is the repository for the Survey of Machine Learning for Big Code and Naturalness.
+Please look at the [website](https://ml4code.github.io) for more information about
+the survey and for information about contributing your work or taxonomy to the website.
\ No newline at end of file
diff --git a/_includes/sidebar.html b/_includes/sidebar.html
index cdda6c84..ae53ea45 100644
--- a/_includes/sidebar.html
+++ b/_includes/sidebar.html
@@ -13,15 +13,19 @@ 
    
     All Papers
 
    Core Taxonomy
-
-
+   Code Generating Models
+   Representational Models
+   Pattern Mining Models
+ Contributing + Contributors
+

Contact Miltos Allamanis about this survey or website

- Made with Jekyll and Lanyon. + Made with Jekyll and Hyde.

diff --git a/_publications/allamanis2013mining.markdown b/_publications/allamanis2013mining.markdown index 1ab2a042..7c9e2c9f 100644 --- a/_publications/allamanis2013mining.markdown +++ b/_publications/allamanis2013mining.markdown @@ -6,6 +6,7 @@ conference: MSR year: 2013 bibkey: allamanis2013mining additional_links: + - {name: "PDF", url: "http://homepages.inf.ed.ac.uk/csutton/publications/msr2013.pdf"} - {name: "data", url: "http://groups.inf.ed.ac.uk/cup/javaGithub/"} - {name: "data@ Edinburgh DataShare", url: "http://datashare.is.ed.ac.uk/handle/10283/2334"} --- diff --git a/_publications/allamanis2014learning.markdown b/_publications/allamanis2014learning.markdown index e6e540f7..06b4f162 100644 --- a/_publications/allamanis2014learning.markdown +++ b/_publications/allamanis2014learning.markdown @@ -6,6 +6,7 @@ conference: FSE year: 2014 bibkey: allamanis2014learning additional_links: + - {name: "PDF", url: "http://homepages.inf.ed.ac.uk/csutton/publications/naturalize.pdf"} - {name: "ArXiV", url: "http://arxiv.org/abs/1402.4182"} - {name: "website", url: "http://groups.inf.ed.ac.uk/naturalize/"} - {name: "code", url: "https://github.com/mast-group/naturalize"} diff --git a/_publications/allamanis2014mining.markdown b/_publications/allamanis2014mining.markdown index 45f195ac..90136e10 100644 --- a/_publications/allamanis2014mining.markdown +++ b/_publications/allamanis2014mining.markdown @@ -6,6 +6,7 @@ conference: FSE year: 2014 bibkey: allamanis2014mining additional_links: + - {name: "PDF", url: "http://homepages.inf.ed.ac.uk/csutton/publications/idioms.pdf"} - {name: "ArXiV", url: "http://arxiv.org/abs/1404.0417"} - {name: "data", url: "http://groups.inf.ed.ac.uk/cup/idioms/haggisClassUsersDataset.zip"} --- diff --git a/_publications/allamanis2015suggesting.markdown b/_publications/allamanis2015suggesting.markdown index dd132baa..9f701989 100644 --- a/_publications/allamanis2015suggesting.markdown +++ b/_publications/allamanis2015suggesting.markdown @@ -6,6 +6,7 @@ conference: FSE year: 2015 bibkey: allamanis2015suggesting additional_links: + - {name: "PDF", url: "http://homepages.inf.ed.ac.uk/csutton/publications/accurate-method-and-class.pdf"} - {name: "website", url: "http://groups.inf.ed.ac.uk/cup/naturalize"} --- Descriptive names are a vital part of readable, and hence maintainable, code. Recent progress on automatically suggesting names for local variables tantalizes with the prospect of replicating that success with method and class names. However, suggesting names for methods and classes is much more difficult. This is because good method and class names need to be functionally descriptive, but suggesting such names requires that the model goes beyond local context. We introduce a neural probabilistic language model for source code that is specifically designed for the method naming problem. Our model learns which names are semantically similar by assigning them to locations, called embeddings, in a high-dimensional continuous space, in such a way that names with similar embeddings tend to be used in similar contexts. These embeddings seem to contain semantic information about tokens, even though they are learned only from statistical co-occurrences of tokens. Furthermore, we introduce a variant of our model diff --git a/base-taxonomy/generative.html b/base-taxonomy/generative.html index 00aef75a..04d9618c 100644 --- a/base-taxonomy/generative.html +++ b/base-taxonomy/generative.html @@ -4,6 +4,10 @@ ---

Code-Generating Models

+Code-generating models define a probability distribution over code by stochastically mod- +eling the generation of smaller and simpler parts of code, e.g. +tokens or AST nodes. + {% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %}
NameTypeRepresentationModelApplication
{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}}{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}} {{publication.pattern_type}} {{publication.representation}} {{publication.application}}
{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}}{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}} {{publication.input_rep}} {{publication.modeled_target}} {{publication.intermediate_rep}}
diff --git a/base-taxonomy/index.md b/base-taxonomy/index.md index 7bf026e9..55b8cb0d 100644 --- a/base-taxonomy/index.md +++ b/base-taxonomy/index.md @@ -11,7 +11,7 @@ distribution and their inputs and outputs. Some models fall into multiple catego because decompositions of their equations fall into different categories. - * [**Code-generating Models**](generative.html) generate code by + * [**Code-generating Models**](generative.html) define a probability distribution over code by stochastically modeling the generation of smaller and simpler parts of code, _e.g._ tokens or AST nodes. diff --git a/base-taxonomy/pattern.html b/base-taxonomy/pattern.html index fffd2bc5..724fbd2f 100644 --- a/base-taxonomy/pattern.html +++ b/base-taxonomy/pattern.html @@ -4,6 +4,10 @@ ---

Pattern Mining Models

+Pattern mining models infer, without supervision, a likely latent +structure within code. These models are an instantiation of clustering +in the code domain; they can find reusable and human-interpretable patterns. + {% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %}
NameTypeRepresentationModelApplication
diff --git a/base-taxonomy/representational.html b/base-taxonomy/representational.html index 00bb7bcc..17c26589 100644 --- a/base-taxonomy/representational.html +++ b/base-taxonomy/representational.html @@ -4,6 +4,11 @@ ---

Representational Models

+Representational models take an abstract representation of +code as input. Example representations include token contexts or data flow. +The resulting model yields a conditional probability distribution over code +element properties, like the types of variables, and can predict them. + {% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %}
NameTypeRepresentationApplication
diff --git a/contributors.md b/contributors.md new file mode 100644 index 00000000..8101812e --- /dev/null +++ b/contributors.md @@ -0,0 +1,18 @@ +--- +layout: default +title: Contributors +--- +The core survey and the original taxonomy was created by + +* [Miltos Allamanis](https://miltos.allamanis.com) Microsoft Research, Cambridge, UK +* [Earl T. Barr](http://earlbarr.com) University College London, London, UK +* [Prem Devanbu](http://web.cs.ucdavis.edu/~devanbu/) University of California, Davis, USA +* [Charles Sutton](http://homepages.inf.ed.ac.uk/csutton/) University of Edinburgh and The Alan Turing Institute, UK + +#### External Contributors +This website accepts external [contributions](/contributing.html). +Please, feel free to add your name below, once you contribute to this +website. + +* Contributor 1 +* Contributor 2 \ No newline at end of file diff --git a/index.md b/index.md index 91310dde..ccfa8315 100644 --- a/index.md +++ b/index.md @@ -15,14 +15,13 @@ research is inherently interdisciplinary, uniting the machine learning and natural language processing communities with software engineering and programming language communities. We present a [taxonomy](\taxnomomy) based on the underlying design principles of each model and use it to navigate -the literature. The full survey text can be found [here](). +the literature. The full survey pre-print can be found [here](). Please cite as 
 TODO
-Regarding this review or website, please contact [Miltos Allamanis](https://miltos.allamanis.com). ### Contributing diff --git a/public/css/hyde.css b/public/css/hyde.css index aafa2f5c..4fa6faec 100644 --- a/public/css/hyde.css +++ b/public/css/hyde.css @@ -91,6 +91,11 @@ html { display: block; line-height: 1.75; } +.sidebar-nav-item-small { + display: block; + font-size: .8rem; + padding-left: 1rem; +} a.sidebar-nav-item:hover, a.sidebar-nav-item:focus { text-decoration: underline; diff --git a/public/css/lanyon.css b/public/css/lanyon.css index 1d57108e..35085eb0 100644 --- a/public/css/lanyon.css +++ b/public/css/lanyon.css @@ -182,6 +182,7 @@ h1, h2, h3, h4, h5, h6 { padding: .5rem 1rem; border-top: 1px solid rgba(255,255,255,.1); } + .sidebar-nav-item.active, a.sidebar-nav-item:hover, a.sidebar-nav-item:focus { From 5ea01f834d10eb407fd14d33283d923a2f7aa2ca Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Tue, 19 Sep 2017 21:08:26 +0100 Subject: [PATCH 27/98] Make tables sortable/filterable. --- _includes/head.html | 11 ++++++++--- base-taxonomy/generative.html | 14 ++++++++++---- base-taxonomy/pattern.html | 15 +++++++++++---- base-taxonomy/representational.html | 14 ++++++++++---- 4 files changed, 39 insertions(+), 15 deletions(-) diff --git a/_includes/head.html b/_includes/head.html index fe492e52..3439d468 100644 --- a/_includes/head.html +++ b/_includes/head.html @@ -22,7 +22,12 @@ - - - + + + + + diff --git a/base-taxonomy/generative.html b/base-taxonomy/generative.html index 04d9618c..eab9b496 100644 --- a/base-taxonomy/generative.html +++ b/base-taxonomy/generative.html @@ -9,17 +9,23 @@

Code-Generating Models

tokens or AST nodes. {% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %} -
NameInput Code RepresentationTargetIntermediate RepresentationApplication
- +
NameTypeRepresentationModelApplication
+ {% for publication in publicationsList %}{% if publication.categories contains "generative" %} {% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} - + {% endif %}{% endfor %} -
NameTypeRepresentationModelApplication
{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}}{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}} {{publication.type}} {{publication.representation}} {{publication.model}} {{publication.application}}
\ No newline at end of file + + + \ No newline at end of file diff --git a/base-taxonomy/pattern.html b/base-taxonomy/pattern.html index 724fbd2f..95186833 100644 --- a/base-taxonomy/pattern.html +++ b/base-taxonomy/pattern.html @@ -9,16 +9,23 @@

Pattern Mining Models

in the code domain; they can find reusable and human-interpretable patterns. {% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %} - - +
NameTypeRepresentationApplication
+ + {% for publication in publicationsList %}{% if publication.categories contains "pattern" %} {% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} - + {% endif %}{% endfor %} -
NameTypeRepresentationApplication
{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}}{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}} {{publication.pattern_type}} {{publication.representation}} {{publication.application}}
\ No newline at end of file + + + \ No newline at end of file diff --git a/base-taxonomy/representational.html b/base-taxonomy/representational.html index 17c26589..f0deb0e2 100644 --- a/base-taxonomy/representational.html +++ b/base-taxonomy/representational.html @@ -10,17 +10,23 @@

Representational Models

element properties, like the types of variables, and can predict them. {% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %} - - +
NameInput Code RepresentationTargetIntermediate RepresentationApplication
+ {% for publication in publicationsList %}{% if publication.categories contains "representational" %} {% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} - + {% endif %}{% endfor %} -
NameInput Code RepresentationTargetIntermediate RepresentationApplication
{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}}{{pubDetails[0].authors}}, {{pubDetails[0].year}}. {{pubDetails[0].title}} {{publication.input_rep}} {{publication.modeled_target}} {{publication.intermediate_rep}} {{publication.application}}
\ No newline at end of file + + + \ No newline at end of file From 008657d68cdf07ad122d59ab0d96df22c8847340 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Tue, 19 Sep 2017 21:28:52 +0100 Subject: [PATCH 28/98] Potential fixes for font issue. --- _includes/head.html | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/_includes/head.html b/_includes/head.html index 3439d468..d3b9c9de 100644 --- a/_includes/head.html +++ b/_includes/head.html @@ -2,6 +2,7 @@ + @@ -18,7 +19,7 @@ - + From 2f2b68e0ac5da433745a8032b17898ce4e04fea4 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Wed, 20 Sep 2017 08:30:25 +0100 Subject: [PATCH 29/98] Added ArXiV link --- _includes/sidebar.html | 6 +++--- index.md | 13 +++++++++++-- 2 files changed, 14 insertions(+), 5 deletions(-) diff --git a/_includes/sidebar.html b/_includes/sidebar.html index ae53ea45..e289258e 100644 --- a/_includes/sidebar.html +++ b/_includes/sidebar.html @@ -23,9 +23,9 @@

-

Contact Miltos Allamanis about this survey or website

-

+

Contact Miltos Allamanis about this survey or website. + Made with Jekyll and Hyde. -

+

diff --git a/index.md b/index.md index b2b7d76d..311db9c5 100644 --- a/index.md +++ b/index.md @@ -26,10 +26,15 @@ you explore the navigate the literautre in this area, by following a [taxonomy](\taxnomomy) based on the underlying design principles of each model. -The full survey is available [as a research paper](). +The full survey is available [as a research paper](https://arxiv.org/abs/1709.06182). Please cite as 
-TODO
+@article{allamanis2017survey,
+  title={A Survey of Machine Learning for Big Code and Naturalness},
+  author={Allamanis, Miltiadis and Brockschmidt, Marc},
+  journal={arXiv preprint arXiv:1709.06182},
+  year={2017}
+}
### Contributing @@ -40,3 +45,7 @@ Anyone can add a paper to this web site, essentially by creating one Markdown fi To contribute, open a pull request in GitHub, by following [these instructions for contributing](contributing.html). +### Datasets and Other Resources +Some resources about Big Code and Naturalness can be found at [learnbigcode.github.io](http://learnbigcode.github.io). +A list of datasets used in this area can be found at the appendix of the +[survey](https://arxiv.org/abs/1709.06182) and at [learnbigcode.github.io](http://learnbigcode.github.io/datasets/). From 5c7c3ec1ad946a258f18cac166c4d80aa07e7a72 Mon Sep 17 00:00:00 2001 From: Vincent Hellendoorn Date: Fri, 22 Sep 2017 10:26:25 -0700 Subject: [PATCH 30/98] Update hellendoorn2017deep.markdown --- _publications/hellendoorn2017deep.markdown | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/_publications/hellendoorn2017deep.markdown b/_publications/hellendoorn2017deep.markdown index 42346ea9..c77ce968 100644 --- a/_publications/hellendoorn2017deep.markdown +++ b/_publications/hellendoorn2017deep.markdown @@ -5,6 +5,10 @@ authors: V. J. Hellendoorn, P. Devanbu conference: FSE year: 2017 bibkey: hellendoorn2017deep +additional_links: + - {name: "Paper", url: "http://vhellendoorn.github.io/PDF/fse2017.pdf"} + - {name: "Slides", url: "http://vhellendoorn.github.io/PPT/FSE17Presentation.pptx"} + - {name: "Code", url: "https://github.com/SLP-Team/SLP-Core"} --- Current statistical language modeling techniques, including deep-learning based models, have proven to be quite effective for source code. We argue here that the special properties of source code can From b84c2dd0a42aeea54eade9972d015d38be970d26 Mon Sep 17 00:00:00 2001 From: Vincent Hellendoorn Date: Fri, 22 Sep 2017 10:28:23 -0700 Subject: [PATCH 31/98] Update hellendoorn2015will.markdown --- _publications/hellendoorn2015will.markdown | 2 ++ 1 file changed, 2 insertions(+) diff --git a/_publications/hellendoorn2015will.markdown b/_publications/hellendoorn2015will.markdown index f2a2c6e6..f38a0e8b 100644 --- a/_publications/hellendoorn2015will.markdown +++ b/_publications/hellendoorn2015will.markdown @@ -5,6 +5,8 @@ authors: V.J. Hellendoorn, P. Devanbu, A. Bacchelli conference: MSR year: 2015 bibkey: hellendoorn2015will +additional_links: + - {name: "Paper", url: "http://vhellendoorn.github.io/PDF/msr2015.pdf"} --- Popular open-source software projects receive and review contributions from a diverse array of developers, many From 58fda9b8271f3b5644623da72c8a1d449b768e29 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sat, 23 Sep 2017 10:47:44 +0100 Subject: [PATCH 32/98] Added some Jekyll plugins. --- _config.yml | 4 ++++ _includes/head.html | 10 +++------- base-taxonomy/index.md | 1 + contributing.markdown | 1 + papers.html | 1 + 5 files changed, 10 insertions(+), 7 deletions(-) diff --git a/_config.yml b/_config.yml index e9f7ad1c..beadfd41 100644 --- a/_config.yml +++ b/_config.yml @@ -9,3 +9,7 @@ collections: publications: output: true permalink: /:collection/:path/ + +plugins: + - jekyll-sitemap + - jekyll-seo-tag diff --git a/_includes/head.html b/_includes/head.html index d3b9c9de..97b4647c 100644 --- a/_includes/head.html +++ b/_includes/head.html @@ -7,13 +7,8 @@ - - {% if page.title == "Home" %} - {{ site.title }} · {{ site.tagline }} - {% else %} - {{ page.title }} · {{ site.title }} - {% endif %} - + {% seo %} + @@ -24,6 +19,7 @@ + + + From fc876803d34ca5de16722e4c95043c62393b4b3e Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Tue, 3 Oct 2017 22:37:07 +0100 Subject: [PATCH 37/98] typo --- index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/index.md b/index.md index ff32ac53..cea36687 100644 --- a/index.md +++ b/index.md @@ -22,7 +22,7 @@ natural language processing communities with software engineering and programming language communities. This site is an experiment: a living literature review that allows -you explore the navigate the literautre in this area, by +you explore the navigate the literature in this area, by following a [taxonomy](\taxnomomy) based on the underlying design principles of each model. From 6b8ad80f45d0cae2afd7f4cd882abc27583c60e2 Mon Sep 17 00:00:00 2001 From: Alexander Date: Wed, 4 Oct 2017 11:30:36 +0200 Subject: [PATCH 38/98] Create markovtsev2017topic.markdown Adding https://arxiv.org/abs/1704.00135 --- _publications/markovtsev2017topic.markdown | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 _publications/markovtsev2017topic.markdown diff --git a/_publications/markovtsev2017topic.markdown b/_publications/markovtsev2017topic.markdown new file mode 100644 index 00000000..2fb2be3a --- /dev/null +++ b/_publications/markovtsev2017topic.markdown @@ -0,0 +1,20 @@ +--- +layout: publication +title: "Topic modeling of public repositories at scale using names in source code" +authors: V. Markovtsev, E. Kant +conference: ArXiV 1704.00135 +year: 2017 +bibkey: markovtsev2017topic +--- + Programming languages themselves have a limited number of reserved keywords and character based tokens that +define the language specification. However, programmers have a rich use of natural language within their code +through comments, text literals and naming entities. The programmer defined names that can be found in source +code are a rich source of information to build a high level understanding of the project. The goal of this paper +is to apply topic modeling to names used in over 13.6 million repositories and perceive the inferred topics. +One of the problems in such a study is the occurrence of duplicate repositories not officially marked as forks (obscure forks). +We show how to address it using the same identifiers which are extracted for topic modeling. + +We open with a discussion on naming in source code, we then elaborate on our approach to remove exact duplicate +and fuzzy duplicate repositories using Locality Sensitive Hashing on the bag-of-words model and then discuss our work +on topic modeling; and finally present the results from our data analysis together with open-access to the source code, +tools and datasets. From fc727d1d8cb45e9b72ec314e0fc8ca28e122c4e2 Mon Sep 17 00:00:00 2001 From: Alexander Date: Wed, 4 Oct 2017 12:25:07 +0200 Subject: [PATCH 39/98] Update markovtsev2017topic.markdown Add links --- _publications/markovtsev2017topic.markdown | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/_publications/markovtsev2017topic.markdown b/_publications/markovtsev2017topic.markdown index 2fb2be3a..3ec6723b 100644 --- a/_publications/markovtsev2017topic.markdown +++ b/_publications/markovtsev2017topic.markdown @@ -5,6 +5,10 @@ authors: V. Markovtsev, E. Kant conference: ArXiV 1704.00135 year: 2017 bibkey: markovtsev2017topic +additional_links: + - {name: "ArXiV", url: "https://arxiv.org/abs/1704.00135"} + - {name: "website", url: "https://blog.sourced.tech/post/github_topic_modeling"} + - {name: "code", url: "https://github.com/src-d/ast2vec/blob/master/topic_modeling.md"} --- Programming languages themselves have a limited number of reserved keywords and character based tokens that define the language specification. However, programmers have a rich use of natural language within their code From 940d37c9dd40eeff6dd8a45809b3273cf2c69930 Mon Sep 17 00:00:00 2001 From: Miltos Date: Sun, 8 Oct 2017 17:18:57 +0100 Subject: [PATCH 40/98] Update papers.html --- papers.html | 2 ++ 1 file changed, 2 insertions(+) diff --git a/papers.html b/papers.html index 8ec97b2f..4c4bef94 100644 --- a/papers.html +++ b/papers.html @@ -2,6 +2,8 @@ layout: default title: List of Publications description: A list of research papers for machine learning models for source code. +Please consider contributing to this list by adding +additional information to existing papers or adding new work. --- Below there is a list of related papers within this area, sorted by year. {% assign publicationsByYear = site.publications | sort: "year" | group_by: "year" %} From 80a1be52cca579f9a384e245cc85fcd7380d2114 Mon Sep 17 00:00:00 2001 From: Miltos Date: Sun, 8 Oct 2017 17:21:10 +0100 Subject: [PATCH 41/98] Update papers.html --- papers.html | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/papers.html b/papers.html index 4c4bef94..a6a5b4cc 100644 --- a/papers.html +++ b/papers.html @@ -2,10 +2,11 @@ layout: default title: List of Publications description: A list of research papers for machine learning models for source code. +--- +Below there is a list of related papers within this area, sorted by year. Please consider contributing to this list by adding additional information to existing papers or adding new work. ---- -Below there is a list of related papers within this area, sorted by year. + {% assign publicationsByYear = site.publications | sort: "year" | group_by: "year" %} {% for year in publicationsByYear reversed %}

{{ year.name }}

From fc5e5a24b3620383be07093413a5633c2e854094 Mon Sep 17 00:00:00 2001 From: Shashank Srikant Date: Tue, 17 Oct 2017 09:13:41 -0400 Subject: [PATCH 42/98] KDD 2014 work by srikant, aggarwal (#6) * KDD 2014 work by srikant, aggarwal A system to grade computer programming skills, KDD 2014. * added lab's URL --- _publications/srikant2014system.markdown | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 _publications/srikant2014system.markdown diff --git a/_publications/srikant2014system.markdown b/_publications/srikant2014system.markdown new file mode 100644 index 00000000..3f8c8011 --- /dev/null +++ b/_publications/srikant2014system.markdown @@ -0,0 +1,12 @@ +--- +layout: publication +title: "A system to grade computer programming skills using machine learning" +authors: S. Srikant, V. Aggarwal +conference: KDD +year: 2014 +bibkey: srikant2014system +additional_links: + - {name: "PDF", url: "https://dl.acm.org/citation.cfm?id=2623377"} + - {name: "website", url: "http://research.aspiringminds.com/"} +--- +The automatic evaluation of computer programs is a nascent area of research with a potential for large-scale impact. Extant program assessment systems score mostly based on the number of test-cases passed, providing no insight into the competency of the programmer. In this paper, we present a system to grade computer programs automatically. In addition to grading a program on its programming practices and complexity, the key kernel of the system is a machine-learning based algorithm which determines closeness of the logic of the given program to a correct program. This algorithm uses a set of highly-informative features, derived from the abstract representations of a given program, that capture the program's functionality. These features are then used to learn a model to grade the programs, which are built against evaluations done by experts. We show that the regression models provide much better grading than the ubiquitous test-case-pass based grading and rivals the grading accuracy of other open-response problems such as essay grading . We also show that our novel features add significant value over and above basic keyword/expression count features. In addition to this, we propose a novel way of posing computer-program grading as a one-class modeling problem and report encouraging preliminary results. We show the value of the system through a case study in a real-world industrial deployment. To the best of the authors' knowledge, this is the first time a system using machine learning has been developed and used for grading programs. The work is timely with regard to the recent boom in Massively Online Open Courseware (MOOCs), which promises to produce a significant amount of hand-graded digitized data. From c75295e14968ef13d4e60b1a7cb8a01bbf768863 Mon Sep 17 00:00:00 2001 From: Shashank Srikant Date: Tue, 17 Oct 2017 09:17:04 -0400 Subject: [PATCH 43/98] KDD 2016 work by singh, srikant, aggarwal (#7) * KDD 2016 work by singh, srikant, aggarwal Question Independent Grading using Machine Learning: The Case of Computer Program Grading, by G Singh, S Srikant, V Aggarwal; KDD 2016 * added lab URL * renamed file had missed out .markdown in it * Remove underscores --- _publications/singh2016question.markdown | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 _publications/singh2016question.markdown diff --git a/_publications/singh2016question.markdown b/_publications/singh2016question.markdown new file mode 100644 index 00000000..7fad74fa --- /dev/null +++ b/_publications/singh2016question.markdown @@ -0,0 +1,12 @@ +--- +layout: publication +title: "Question Independent Grading using Machine Learning: The Case of Computer Program Grading" +authors: G. Singh, S. Srikant, V. Aggarwal +conference: KDD +year: 2016 +bibkey: singh2016question +additional_links: + - {name: "PDF", url: "https://dl.acm.org/citation.cfm?id=2939696"} + - {name: "website", url: "http://research.aspiringminds.com/"} +--- +Learning supervised models to grade open-ended responses is an expensive process. A model has to be trained for every prompt/question separately, which in turn requires graded samples. In automatic programming evaluation specifically, the focus of this work, this issue is amplified. The models have to be trained not only for every question but also for every language the question is offered in. Moreover, the availability and time taken by experts to create a labeled set of programs for each question is a major bottleneck in scaling such a system. We address this issue by presenting a method to grade computer programs which requires no manually assigned labeled samples for grading responses to a new, unseen question. We extend our previous work (by Srikant, Aggarwal; KDD 2014) wherein we introduced a grammar of features to learn question specific models. In this work, we propose a method to transform those features into a set of features that maintain their structural relation with the labels across questions. Using these features we learn one supervised model, across questions for a given language, which can then be applied to an ungraded response to an unseen question. We show that our method rivals the performance of both, question specific models and the consensus among human experts while substantially outperforming extant ways of evaluating codes. We demonstrate the system single s value by deploying it to grade programs in a high stakes assessment. The learning from this work is transferable to other grading tasks such as math question grading and also provides a new variation to the supervised learning approach. From e66cce4e72aa38f2abdc32311e2be68467bddbc7 Mon Sep 17 00:00:00 2001 From: Eddie Antonio Santos Date: Mon, 30 Oct 2017 12:16:17 -0600 Subject: [PATCH 44/98] Fix homepage link to Taxonomy page. --- index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/index.md b/index.md index cea36687..73c364a8 100644 --- a/index.md +++ b/index.md @@ -23,7 +23,7 @@ and programming language communities. This site is an experiment: a living literature review that allows you explore the navigate the literature in this area, by -following a [taxonomy](\taxnomomy) +following a [taxonomy]({% link base-taxonomy/index.md %}) based on the underlying design principles of each model. The full survey is available [as a research paper](https://arxiv.org/abs/1709.06182). From f08be169d085cc5f573cad51bb53037a2919ef70 Mon Sep 17 00:00:00 2001 From: Miltos Allamanis Date: Sat, 16 Dec 2017 21:38:25 +0000 Subject: [PATCH 45/98] A set of changes to make the website a bit more useful. * All search fields now can also search into the abstracts. * "Other Resources" now have their own page. * A few stylistic changes. --- _config.yml | 2 +- _includes/head.html | 10 ++----- _includes/sidebar.html | 3 +- base-taxonomy/generative.html | 17 +++++++++--- base-taxonomy/pattern.html | 15 ++++++++-- base-taxonomy/representational.html | 15 ++++++++-- contributors.md | 6 ++-- index.md | 19 +++++-------- papers.html | 43 +++++++++++++++++++++-------- public/css/hyde.css | 11 +++++++- public/css/poole.css | 8 +++--- resources.md | 13 +++++++++ 12 files changed, 111 insertions(+), 51 deletions(-) create mode 100644 resources.md diff --git a/_config.yml b/_config.yml index beadfd41..8dab8c1f 100644 --- a/_config.yml +++ b/_config.yml @@ -1,7 +1,7 @@ # Setup title: Machine Learning for Big Code and Naturalness tagline: 'a survey' -description: 'A survey of academic research on machine learning models for source code.' +description: 'A survey of research on machine learning for source code.' url: https://ml4code.github.io baseurl: '' diff --git a/_includes/head.html b/_includes/head.html index c78570de..603d6efd 100644 --- a/_includes/head.html +++ b/_includes/head.html @@ -5,7 +5,6 @@ window.dataLayer = window.dataLayer || []; function gtag(){dataLayer.push(arguments)}; gtag('js', new Date()); - gtag('config', 'UA-107339008-1'); @@ -19,7 +18,6 @@ {% seo %} - @@ -28,13 +26,11 @@ - - - - + + diff --git a/_includes/sidebar.html b/_includes/sidebar.html index e289258e..a6c430e5 100644 --- a/_includes/sidebar.html +++ b/_includes/sidebar.html @@ -10,7 +10,7 @@

diff --git a/base-taxonomy/generative.html b/base-taxonomy/generative.html index eab9b496..69364ad9 100644 --- a/base-taxonomy/generative.html +++ b/base-taxonomy/generative.html @@ -10,7 +10,7 @@

Code-Generating Models

{% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %} - + {% for publication in publicationsList %}{% if publication.categories contains "generative" %} {% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} @@ -20,12 +20,21 @@

Code-Generating Models

+ {% endif %}{% endfor %}
NameTypeRepresentationModelApplication
NameTypeRepresentationModelApplicationAbstract
{{publication.representation}} {{publication.model}} {{publication.application}}{{pubDetails[0].content}}
\ No newline at end of file + $('#genModelTable').DataTable({ + paging: false, + columnDefs: [ + { + targets: [5], + visible: false, + searchable: true + }] + }); +}); + diff --git a/base-taxonomy/pattern.html b/base-taxonomy/pattern.html index 95186833..371804fd 100644 --- a/base-taxonomy/pattern.html +++ b/base-taxonomy/pattern.html @@ -10,7 +10,7 @@

Pattern Mining Models

{% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %} - + {% for publication in publicationsList %}{% if publication.categories contains "pattern" %} {% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} @@ -20,12 +20,21 @@

Pattern Mining Models

+ {% endif %}{% endfor %}
NameTypeRepresentationApplication
NameTypeRepresentationApplicationAbstract
{{publication.pattern_type}} {{publication.representation}} {{publication.application}}{{pubDetails[0].content}}
\ No newline at end of file + diff --git a/base-taxonomy/representational.html b/base-taxonomy/representational.html index f0deb0e2..14b2dcd8 100644 --- a/base-taxonomy/representational.html +++ b/base-taxonomy/representational.html @@ -11,7 +11,7 @@

Representational Models

{% assign publicationsList = site.data.allamanistaxonomy | sort: "bibkey" %} - + {% for publication in publicationsList %}{% if publication.categories contains "representational" %} {% assign pubDetails = site.publications | where:"bibkey", publication.bibkey %} @@ -21,12 +21,21 @@

Representational Models

+ {% endif %}{% endfor %}
NameInput Code RepresentationTargetIntermediate RepresentationApplication
NameInput Code RepresentationTargetIntermediate RepresentationApplicationAbstract
{{publication.modeled_target}} {{publication.intermediate_rep}} {{publication.application}}{{pubDetails[0].content}}
\ No newline at end of file + diff --git a/contributors.md b/contributors.md index 8101812e..5d1704f4 100644 --- a/contributors.md +++ b/contributors.md @@ -9,10 +9,10 @@ The core survey and the original taxonomy was created by * [Prem Devanbu](http://web.cs.ucdavis.edu/~devanbu/) University of California, Davis, USA * [Charles Sutton](http://homepages.inf.ed.ac.uk/csutton/) University of Edinburgh and The Alan Turing Institute, UK -#### External Contributors +#### Contributors to the website This website accepts external [contributions](/contributing.html). Please, feel free to add your name below, once you contribute to this -website. +website. A comprehensive list can be found [here](https://github.com/ml4code/ml4code.github.io/graphs/contributors). * Contributor 1 -* Contributor 2 \ No newline at end of file +* Contributor 2 diff --git a/index.md b/index.md index 73c364a8..2066aec2 100644 --- a/index.md +++ b/index.md @@ -3,17 +3,18 @@ layout: default title: A Survey of Machine Learning for Big Code and Naturalness --- -The billions of lines of source code that have been written contain +### Machine Learning on Source Code + +The billions of lines of source code that have been written contain implicit knowledge about how to write good code, code that is easy to read and to debug. A recent line of research aims to find statistical patterns in large -corpora of code to drive new software development tools and program -analyses. +corpora of code to drive *new software development tools and program +analyses*. -This website and the accompanying article surveys the work in this emerging area. +This website and the accompanying [article](https://arxiv.org/abs/1709.06182) surveys the work in this emerging area. Like writing and speaking, software development is an act of human communication. - At its core, the naturalness of software employs statistical modeling over big code to reason about rich variety of programs developers write. This new line of @@ -22,10 +23,9 @@ natural language processing communities with software engineering and programming language communities. This site is an experiment: a living literature review that allows -you explore the navigate the literature in this area, by +you explore and navigate the literature in this area, by following a [taxonomy]({% link base-taxonomy/index.md %}) based on the underlying design principles of each model. - The full survey is available [as a research paper](https://arxiv.org/abs/1709.06182). Please cite as 
@@ -44,8 +44,3 @@ But a website can! We hope to make this site a living document.
 Anyone can add a paper to this web site, essentially by creating one Markdown file.
  To contribute, open a pull request in GitHub, by following [these instructions 
 for contributing](contributing.html).
-
-### Datasets and Other Resources
-Some resources about Big Code and Naturalness can be found at [learnbigcode.github.io](http://learnbigcode.github.io).
-A list of datasets used in this area can be found at the appendix of the
-[survey](https://arxiv.org/abs/1709.06182) and at [learnbigcode.github.io](http://learnbigcode.github.io/datasets/).
diff --git a/papers.html b/papers.html
index a6a5b4cc..09c5cf5e 100644
--- a/papers.html
+++ b/papers.html
@@ -1,21 +1,40 @@
 ---
 layout: default
-title: List of Publications
+title: Search all Publications on Machine Learning for Source Code
 description: A list of research papers for machine learning models for source code.
 ---
-Below there is a list of related papers within this area, sorted by year. 
-Please consider contributing to this list by adding
-additional information to existing papers or adding new work.
+Search across all paper titles, abstracts, authors by using the search field.
+Please consider contributing by updating
+the information of existing papers or adding new work.
 
+
+
 {% assign publicationsByYear = site.publications | sort: "year" | group_by: "year" %}
 {% for year in publicationsByYear reversed %}
-  
{{ year.name }}

-    
    
-      {% for publication in year.items %}
-      
  • 
-          {{publication.title}}. {{ publication.authors }}. {{publication.conference}}.
-      
    • 
-    {% endfor %}
-    

+{% for publication in year.items %}
+
+	
+	
+	
+	
+	
+
 {% endfor %}
+{% endfor %}
+
YearTitleAuthorsVenueAbstract
{{ publication.year }} {{publication.date}} {{publication.title}}{{ publication.authors }}{{ publication.conference }}{{ publication.content }}

+
+
 
diff --git a/public/css/hyde.css b/public/css/hyde.css
index 4fa6faec..b79d8780 100644
--- a/public/css/hyde.css
+++ b/public/css/hyde.css
@@ -80,7 +80,7 @@ html {
   color: #fff;
   margin-top: 0;
   font-family: "Abril Fatface", serif;
-  font-size: 2.25rem;
+  font-size: 2rem;
 }
 
 /* Sidebar nav */
@@ -257,3 +257,12 @@ td {
 .theme-base-0f .related-posts li a:hover {
   color: #8f5536;
 }
+
+#pubslist {
+  font-size: 0.8rem;
+}
+
+#pubslist ul {
+  padding-left: 0;
+  list-style-type: square;
+}
diff --git a/public/css/poole.css b/public/css/poole.css
index 8ec27e7a..62759025 100644
--- a/public/css/poole.css
+++ b/public/css/poole.css
@@ -164,8 +164,8 @@ pre {
   margin-top: 0;
   margin-bottom: 1rem;
   padding: 1rem;
-  font-size: .8rem;
-  line-height: 1.4;
+  font-size: .6rem;
+  line-height: 1.2;
   white-space: pre;
   white-space: pre-wrap;
   word-break: break-all;
@@ -190,7 +190,7 @@ pre code {
 
 /* Gist via GitHub Pages */
 .gist .gist-file {
-  font-family: Menlo, Monaco, "Courier New", monospace !important;
+  font-family: Consolas, Menlo, Monaco, "Courier New", monospace !important;
 }
 .gist .markdown-body {
   padding: 15px;
@@ -259,7 +259,7 @@ tbody tr:nth-child(odd) th {
  */
 
 .lead {
-  font-size: 1.25rem;
+  font-size: 1.1rem;
   font-weight: 300;
 }
 
diff --git a/resources.md b/resources.md
new file mode 100644
index 00000000..c257af1a
--- /dev/null
+++ b/resources.md
@@ -0,0 +1,13 @@
+---
+layout: default
+title: Resources on Machine Learning for Big Code and Naturalness
+---
+
+### Datasets
+Some resources about Big Code and Naturalness can be found at [learnbigcode.github.io](http://learnbigcode.github.io).
+A list of datasets used in this area can be found at the appendix of the
+[survey](https://arxiv.org/abs/1709.06182) and at [learnbigcode.github.io](http://learnbigcode.github.io/datasets/).
+
+### Other Collections of Related Work
+[Source{d}](https://sourced.tech/) has collected a set of links and
+papers in the area. You can access the list [here](https://github.com/src-d/awesome-machine-learning-on-source-code).

From d5b8ec8d55e8d0752bb044310754337b1c30c23f Mon Sep 17 00:00:00 2001
From: Miltos Allamanis 
Date: Sat, 16 Dec 2017 22:25:29 +0000
Subject: [PATCH 46/98] chore: fix links.

---
 _includes/sidebar.html | 18 +++++++++---------
 base-taxonomy/index.md |  6 +++---
 index.md               |  2 +-
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/_includes/sidebar.html b/_includes/sidebar.html
index a6c430e5..7ffea686 100644
--- a/_includes/sidebar.html
+++ b/_includes/sidebar.html
@@ -10,17 +10,17 @@ 

     
 
   
 
   

diff --git a/base-taxonomy/index.md b/base-taxonomy/index.md
index 48be17fb..68f4eef0 100644
--- a/base-taxonomy/index.md
+++ b/base-taxonomy/index.md
@@ -12,17 +12,17 @@ distribution and their inputs and outputs. Some models fall into multiple catego
 because decompositions of their equations fall into different categories.
 
 
- * [**Code-generating Models**](generative.html) define a probability distribution over code by 
+ * [**Code-generating Models**]({% link base-taxonomy/generative.html %}) define a probability distribution over code by 
     stochastically modeling the generation of smaller and simpler parts of code, _e.g._
     tokens or AST nodes.
 
- * [**Representational Models of Code**](representational.html) take an abstract
+ * [**Representational Models of Code**]({% link base-taxonomy/representational.html %}) take an abstract
     representation of 
     code as input.  Example representations include token contexts or data flow.
     The resulting model yields a conditional probability distribution over code
     element properties, like the types of variables, and can predict them.
 
- * [**Pattern Mining Models**](pattern.html) infer, without supervision, a likely latent
+ * [**Pattern Mining Models**]({% link base-taxonomy/pattern.html %}) infer, without supervision, a likely latent
     structure within code. These models are an instantiation of clustering
     in the code domain; they can find reusable and human-interpretable patterns.
 
diff --git a/index.md b/index.md
index 2066aec2..71d1138f 100644
--- a/index.md
+++ b/index.md
@@ -23,7 +23,7 @@ natural language processing communities with software engineering
 and programming language communities. 
 
 This site is an experiment: a living literature review that allows
-you explore and navigate the literature in this area, by
+you explore, [search and navigate]({% link papers.html %}) the literature in this area, by
 following a [taxonomy]({% link base-taxonomy/index.md %})
 based on the underlying design principles of each model.
 The full survey is available [as a research paper](https://arxiv.org/abs/1709.06182).

From 2d983e29ad329361dd3a6bd788d4d04a3255ecd9 Mon Sep 17 00:00:00 2001
From: Miltos Allamanis 
Date: Sat, 16 Dec 2017 23:07:56 +0000
Subject: [PATCH 47/98] Added recent work.

---
 _includes/head.html                           |  2 +-
 _publications/allamanis2015bimodal.markdown   |  2 +-
 _publications/allamanis2017learning.markdown  | 13 +++++++
 .../bavishi2017context2name.markdown          | 21 ++++++++++++
 _publications/li2017code.markdown             | 12 +++++++
 _publications/pradel2017deep.markdown         | 34 +++++++++++++++++++
 _publications/yang2017language.markdown       | 11 ++++++
 _publications/yuan2017abridging.markdown      | 11 ++++++
 papers.html                                   |  2 +-
 9 files changed, 105 insertions(+), 3 deletions(-)
 create mode 100644 _publications/allamanis2017learning.markdown
 create mode 100644 _publications/bavishi2017context2name.markdown
 create mode 100644 _publications/li2017code.markdown
 create mode 100644 _publications/pradel2017deep.markdown
 create mode 100644 _publications/yang2017language.markdown
 create mode 100644 _publications/yuan2017abridging.markdown

diff --git a/_includes/head.html b/_includes/head.html
index 603d6efd..c03151c4 100644
--- a/_includes/head.html
+++ b/_includes/head.html
@@ -25,7 +25,7 @@
   
 
   
-  
+  
 
   
diff --git a/index.md b/index.md
index cda19674..c548e185 100644
--- a/index.md
+++ b/index.md
@@ -2,7 +2,6 @@
 layout: default
 title: A Survey of Machine Learning for Big Code and Naturalness
 ---
-
 ### Machine Learning on Source Code
 
 The billions of lines of source code that have been written contain 
diff --git a/papers.html b/papers.html
index 4acee407..a4f0a72e 100644
--- a/papers.html
+++ b/papers.html
@@ -30,8 +30,16 @@
 
 
 
 

From e0f67ac613684b7a1eaa75976d4c0f78e93a18b6 Mon Sep 17 00:00:00 2001
From: Miltos Allamanis 
Date: Sat, 3 Mar 2018 19:18:16 +0000
Subject: [PATCH 64/98] Decode search string.

---
 papers.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/papers.html b/papers.html
index a4f0a72e..1496e606 100644
--- a/papers.html
+++ b/papers.html
@@ -33,7 +33,7 @@
 var datatable;
 
 function searchTable() {
-    var hash = window.location.hash.substr(1);
+    var hash = decodeURIComponent(window.location.hash.substr(1));
     datatable.search(hash).draw();
 }
 

From 2ca96c0e4a96bd35362727d8a3f21762f2a14498 Mon Sep 17 00:00:00 2001
From: Waren Long 
Date: Thu, 29 Mar 2018 19:38:49 +0200
Subject: [PATCH 65/98] Add MSR 2018 datashowcase paper by Markovtsev, Long

---
 _publications/markovtsev2018public.markdown | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 _publications/markovtsev2018public.markdown

diff --git a/_publications/markovtsev2018public.markdown b/_publications/markovtsev2018public.markdown
new file mode 100644
index 00000000..416f3668
--- /dev/null
+++ b/_publications/markovtsev2018public.markdown
@@ -0,0 +1,13 @@
+---
+layout: publication
+title: "Public Git Archive: a Big Code dataset for all"
+authors: V. Markovtsev, W. Long
+conference: MSR
+year: 2018
+bibkey: markovtsev2018public
+additional_links:
+   - {name: "ArXiV", url: "https://arxiv.org/abs/1803.10144"}
+   - {name: "GitHub", url: "https://github.com/src-d/datasets/tree/master/PublicGitArchive"}
+   - {name: "data", url: "http://pga.sourced.tech/"}
+---
+The number of open source software projects has been growing exponentially. The major online software repository host, GitHub, has accumulated tens of millions of publicly available Git version-controlled repositories. Although the research potential enabled by the available open source code is clearly substantial, no significant large-scale open source code datasets exist. In this paper, we present the Public Git Archive -- dataset of 182,014 top-bookmarked Git repositories from GitHub. We describe the novel data retrieval pipeline to reproduce it. We also elaborate on the strategy for performing dataset updates and legal issues. The Public Git Archive occupies 3.0 TB on disk and is an order of magnitude larger than the current source code datasets. The dataset is made available through HTTP and provides the source code of the projects, the related metadata, and development history. The data retrieval pipeline employs an optimized worker queue model and an optimized archive format to efficiently store forked Git repositories, reducing the amount of data to download and persist. Public Git Archive aims to open a myriad of new opportunities for Big Code research. 

From 5581783b1cc1a470b55613ad681fe9ed9dc11484 Mon Sep 17 00:00:00 2001
From: Charles Sutton 
Date: Thu, 29 Mar 2018 19:21:15 -0400
Subject: [PATCH 66/98] Update resources.md

Fix typo
---
 resources.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/resources.md b/resources.md
index e312f381..84685f6c 100644
--- a/resources.md
+++ b/resources.md
@@ -9,7 +9,7 @@ A list of datasets used in this area can be found at the appendix of the
 [survey](https://arxiv.org/abs/1709.06182) and at [learnbigcode.github.io](http://learnbigcode.github.io/datasets/).
 
 ### Courses
-A few university courses are been taught covering aspects of machine learning for code, big code or naturalnness of code. Below there are a few that have publicly availably material.
+A few university courses are been taught covering aspects of machine learning for code, big code or naturalnness of code. Below there are a few that have publicly available material.
 * [Analyzing Software using Deep Learning](https://www.sola.tu-darmstadt.de/de/software-lab/teaching/summer-2017/analyzing-software-using-deep-learning/analyzing-software-using-deep-learning-summer-semester-2017/) in T.U. Darmstadt
 * [Seminars on Applications of Deep Learning in Software Engineering and Programming Languages](https://sites.google.com/view/mlplse-sp18/) in U.C. Berkeley
 

From 00d073a4914062cb894801b5d2230d795e907fa4 Mon Sep 17 00:00:00 2001
From: Miltos Allamanis 
Date: Fri, 30 Mar 2018 00:48:46 +0100
Subject: [PATCH 67/98] Add as Open Search provider, to allow adding this in
 browsers.

I don't know if anyone else will use this, though.
---
 _includes/head.html              |  3 +++
 public/opensearchdescription.xml | 10 ++++++++++
 2 files changed, 13 insertions(+)
 create mode 100644 public/opensearchdescription.xml

diff --git a/_includes/head.html b/_includes/head.html
index c03151c4..6b94464c 100644
--- a/_includes/head.html
+++ b/_includes/head.html
@@ -26,6 +26,9 @@
 
   
   
+