Americans purchase nearly $30b of pet food per year, the vast majority of which is generic, mass-manufactured product sold through traditional retailers

Nom Nom

nomnom

nCent Announces Endgame of Revolutionary Hackathon . The Hunger Games: Catching Fire © 2013 Lions Gate Films Inc. All Rights Reserved. There can only be one winner at hackCent On August 18th, 2018, nCent sponsored the first ever global hackathon event focused on hacking incentives on a . 27 participants gathered at our Silicon Valley headquarters to fight tooth and nail at their keyboards. They hailed from places like Utah and Montana to Mexico City and Cambridge. blockchain Their goal? To build the best application using the nCent and to demonstrate . After meeting one another, 10 teams formed, and 3 finalists emerged. The finalists were selected by a panel that included special judge Narendran Thiagarajan from and by the votes of our entire telegram community, . These 3 finalist teams are advancing to the endgame, which will end in one week from today (Monday, August 20th). SDK sandbox the power of incentive markets FloydHub nCent Nation The winning team will be announced next Monday, August 27th at 5pm PST. The criterion will be most Github contributors — so YOU can help choose by voting with which project YOU want to develop! Hackathon participants grinding out incentive hacks Since exiting stealth mode a month ago, we have put a lot of effort into development at nCent. Events like hackCent remind us that we have made progress — so much so that our hackathon participants built applications on our protocol within a few hours. The proof of concept exists, and the is getting noticed. technology Still, these events also remind us that there is also room to improve. Despite the growing pains we observed, when all was said and done, we pulled off a successful hackathon. We learned a lot in the process, especially from the teams that worked through our repositories on GitHub and helped us fix bugs along the way. We would like to thank all of the participants that made hackCent possible. There will be more events like hackCent in the near future, and we hope that you will join our mission to unlock the untapped potential of our networks through incentive hacking. What we value most is the knowledge we gained by hacking together. Our 3 Finalists 1. learnCent Congratulations to learnCent for becoming finalists! Click here to watch their Demo Pitch. Dustin Pearson, Cody Rose, Daniel Edwards, Chris Morehouse and Mohit Jain “I’m fascinated by the innovative idea of using personal networks to solve search problems. nCent is truly on the frontier of technology.” — Dustin Pearson learnCent is a peer-to-peer tutoring platform connecting students and tutors on university campuses learnCent’s application UI Click here to contribute to learnCent’s GitHub! 2. NomNomCent Congratulations to finalist Jovan Jester, creator of nomNomCent! ! Click here to watch his Demo Pitch Co-founders of nomNomCent: Jovan Jester and Teddy Bear “Now that I’ve poked around the code a bit, participated in the hackathon, and seen others’ ideas, the full potential of what incentive markets powered by nCent could unleash has dawned on me.” — Jovan Jester nomNomCent is a social platform for sharing food and discovering restaurants driving engagement through recursive incentives. nomNomCent‘s landingpage Click here to contribute to nomNomCent’s GitHub! 3. challengeCent Congratulations to challengeCent for being our last finalists! ! Click here to watch their Demo Pitch Khalid Imam, Klarence OuYang and Michael Vavro ChallengeCent is an application that incentivizes social activity and events to “get people off their asses!” challengeCent’s application UI Click here to contribute to challengeGitHub’s logic! Let the Endgames Begin! Our three finalists now have until Monday, August 27th at 5pm PST to continue working on their projects before submitting a final demo video for evaluation. As of right now, each of the finalists has been awarded one ETH. Like all of our contests, however, ! there is always a twist involving recursive incentives We are allowing the finalists to recruit collaborators to help with their codes, which can be found on . Contributors must provide a logic improvement to the project’s code, as determined by the team at nCent. Rewards will be allocated as follows: the projects’ repositories on our public Github The team with the most contributors gets double earnings (2 ETH). When all three projects together get more than 50 contributors, all the rewards are doubled (4 ETH, 2 ETH, 2 ETH). When all three projects together get more than 100 contributors, all the rewards are multiplied by 6 (12 ETH, 6 ETH, 6 ETH). When all three projects together get more than 200 contributors, all the rewards are multiplied by 20 (40 ETH, 20 ETH, 20 ETH). Let the games begin! Videos of hackCent Each of the 10 teams demoed and pitched their applications. The event was livestreamed and lasted about 12 hours (before the afterparty). More hackCent Projects 4. ButtonTeam Alexandr Safonov and Kirill Kuznetsov ButtonTeam joined us remotely from New York City and developed a telegram wallet for NCNT. nCoin Wallet by ButtonTeam “We are developing a wallet for nCent based on telegram. Telegram users could use this wallet inside of telegram and transfer nCent’s tokens. Also, we are trying to make it all with QR code.” — ButtonTeam 5. sportCent Tim Ryan and Don Kim SportCent created a sports merchandising application for professional teams. sportCent’s application UI 6. EventCent Timmy Jing, Ryan Myer, Drew Stukey and Stephan Kang Team 50centive built eventCent, an application that allows fans to vote on their favorite artists’ future venue locations. EventCent’s user portal 7. TaskCent Felix Alvarado, Shashank Racherla and Nathaniel Cunha TaskCent is an application that allows people to find other users to complete their task using nCent’s API. TaskCent’s splash page 8. QCoin Andzu Schaefer, Matt Wojick and Qi Huang QCoin is an application that helps gamers find the right teammates through a recursively incentivized referral program. 9. jobCent Dan Luo and Alex Gonzalez worked on their own implementation of , one of our launch applications that helps employers hire the ideal candidates. jobCent Thanks Dan and Alex for your jobCent contributions! 10. Liquid Democracy Arya Soltanieh created LiquidDemocracy, an application that would allow governments, companies, and organizations to hold special votes. On the liquid democracy model, anyone can vote directly or delegate their vote to another individual. To keep informed about our latest events and to help us build the future of incentive markets, join our project at nCent Labs . Feel free to email me anytime: kk@ncnt.io .

10 Teams Enter. 1 Team Leaves… Let the Games Begin!

Recently, I read a post on Hackernoon by Aashay Sanghvi titled “The Startup Scene at Harvard”. It was very well-crafted and I found it super interesting to take a peek into the startup scene of a top entrepreneurship school in the nation. It inspired me to write my own version of the post to give prospective Brunonians an idea of what Brown is like and to give past alums some pride on how much the scene has grown since they graduated. If you haven’t read his post yet, check it out below! _Dropping out is normally what comes to mind when people think of “Harvard” and “startups.”_hackernoon.com The Startup Scene at Harvard When you think of hubs for undergraduate entrepreneurs, is usually not the first university that comes to mind. Harvard, MIT, or Stanford usually take that laurel but Brown University is certainly on the rise. With the creation of a new centralized physical location for entrepreneurship, Brown’s scene is booming. Here’s the scoop on some of the things happening on Brown Street nowadays (as of Feb. 2017). Brown startup Clubs: EP is a student-run entrepreneurial initiative on campus and the biggest hub for young entrepreneurs. It is the umbrella organization for many great entrepreneurial resources on campus including Innovation Dojo, Startup Office Hours, Startup @Brown, and many others! Its alumni board consists of notable alumni such as Jeff Stibel, co-founder of Bryant Stibel, and Bob Goodman, a board member at Bessemer Venture Partners. This semester, its budget nearly doubled due to generous alumni funding so expect bigger and better things from them! Brown Entrepreneurial Program (EP) : Innovation Dojo is an EP workshop series that aims to introduce 1st and 2nd year Brunonians to entrepreneurship and the resources available to them on the hill. They hold meetings every week where experts give masterclass workshops on a variety of topics in entrepreneurship. All of this ties into a personal project where you work on your own startup or plan one out for the future and present it to the entrepreneurship community! Innovation Dojo : The Rhode Island School of Design (RISD) is the sister school of Brown and all clubs at both schools are open to students from both campuses. RISD E’Ship has a strong network of student entrepreneurs as well as its own startup accelerator program, E Partners Program, that provides funding and mentorship to student ventures. RISD E’Ship : HCRI is a student group dedicated to the advancement of robotics as a means to benefit human society economically and socially. Their aim is to create and understand robots that coexist harmoniously with humans. They often put up visual and interactive presentations on the bottom floor of the Computer Science building (CIT) to showcase their recent works. Humanity-Centered Robotics Initiative : A collaboration between the Warren Alpert Medical School of Brown University and the Rhode Island School of Design, Design+Health is an incubator which encourages students across all disciplines to develop and implement design solutions that address clinical and public health concerns. Design+Health : VC Presence: DRF is a student-focused venture fund of First Round Capital. They’re the largest student-run venture firm in the nation, funding and supporting an incredibly talented community of student entrepreneurs which now includes the Brown community, as they recently brought on Haris Memon (Brown ’19) as Head of Marketing for the firm. Dorm Room Fund : To date, Dorm Room Fund has made 125+ investments. Their portfolio companies have gone on to raise $200M+ in follow-on funding from investors like Andreessen Horowitz, Sequoia Capital, and Y Combinator. RDV, like Dorm Room Fund, is a student-focused VC firm backed by General Catalyst. It currently has a strong presence at universities in Boston and NYC, and our very own Valentin Perez (Brown ’18 + Former Co-President of Brown EP) is a partner. Rough Draft Ventures : Rough Draft Ventures has made 90+ investments, with portfolio companies raising follow-on funding of $230M+ from investors like SV Angel, Y Combinator, and Lerer Ventures. : Evertrue Ventures is a community of Brown alumni, investors, entrepreneurs, and innovators with a passion for supporting Brown alumni-led startups. Evertrue Ventures Events: Startup@Brown is a two-day conference hosted by EP every fall for startups across the nation come together on Brown’s campus. Many come to find new talent to join their team as well as hold office hours for young entrepreneurs looking for advice or someone to bounce ideas off of. Workshops led by industry professionals are held throughout the day where students can learn about accelerating their startup, plotting a career in tech, or building a healthy startup culture. This year, Startup@Brown was held in October with speakers coming from notable companies including Rough Draft Ventures, WayUp, and Techstars. Startup@Brown: We@Brown, the Women’s Empowerment Conference, aims to empower women to pursue their professional passions. Hosted by the Lady Launchers team at Brown EP, this year’s event will feature prominent female leaders in business and tech including Melanie Whelan, the CEO of Soulcycle, Laura Thompson, a VC Investor at Google Ventures and Co-founder of Runa tea, and Marian Salzman, the CEO of Havas PR North America. WE@Brown : In an all-expenses-paid trip, students will have the opportunity to visit a startup hub with their peers at EP. Activities include private tours of notable companies, dinners with successful Brown alumni, and opportunities to network with professionals in entrepreneurship and technology. In the past, Synapse has paid visits to NYC, SF, and LA, visiting companies such as KPCB, Apple, and Dropbox. In the future, Brunonians may have the opportunity to experience business cultures in a variety of different countries. Synapse: Hack@Brown is a two-day hackathon hosted by Brown, bringing hackers of all skill levels from all around the country together to spend a weekend programming, networking, and learning new technologies. Workshops are held before and throughout the event. Hack@Brown is a staple event for any CS concentrator at Brown. Hack@Brown: Nelson Center for Entrepreneurship A recent addition to the Brown startup landscape after a $25M donation from Jonathan Nelson ’77, the Nelson Center for Entrepreneurship acts as a nexus for entrepreneurial education by giving the community a visible space for all of its resources. Startup Office Hours, which brings highly-accomplished individuals from around the community to Brown to have one-on-one meetings with aspiring students entrepreneurs, calls the Nelson Center its home. The center also has five Peer Entrepreneurs-in-Residence (PIERS) who provide guidance and mentorship to those working on a new venture or are interested in learning how to join the entrepreneurial community at Brown. Along with these personal mentorship sessions, the center has held startup event series, , and film screenings for the community. The center is currently operating out of a temporary location right now but once the official center is completed next semester, its activities will only ramp up. major academic conferences Cool Startups at Brown: DocTalk mobile app that seeks to tackle many of the inefficiencies of the healthcare system in India. It facilitates interaction with your doctor by creating a clear channel of communication with them through the app, hosting on-the-go storage for all your medical files, and providing a means for effortless mobile requests for your prescriptions. Founded by Krishna Chaitanya Aluru ’17 of Brown, Akshat Goenka ’14 of Wharton, and Vamsee Chamakura ’17 of IIIT, DocTalk is currently going through Y-Combinator’s winter batch. DocTalk : is a Nomnomz offers two services: Nomnomz Checkout, which provides self-service checkout kiosks for restaurants, and Nomnomz Collegiate, a food pre-ordering service tailored for college campuses. It’s founder and CEO, ’18, is a strong contributor to Brown’s startup scene. Nomnomz : Matthew DiMarcantonio Bonsai is a high-end fashion and lifestyle marketplace HQ’d in Toronto. The team has raised over $780,000 in its first two funding rounds and is partnered with notable brands such as Acne Studios, Helmut Lang, and Balmain. Its Co-Founder & CFO, Kunal Khemani ’19, is currently taking a semester off in Toronto to devote full-time attention towards the platform. Bonsai : Speechify is a text-to-speech software that allows the user to listen to any text with a voice and speed of their choosing. It boasts multilingual support across accents and languages and makes efficient use of keyboard shortcuts for a smooth experience. Another nice feature of the app is the ability to create custom audiobooks instantly by highlighting any text on your phone or computer. Its founder Cliff Weitzman ’18 was recently recognized as a part of the 2017 Forbes 30 under 30 list in Education. Speechify: Bruno Innovation for Life: Our strong entrepreneurial spirit on campus has led to some amazing startups being founded by alumni, including: Casper ( ‘12, ’12, Gabriel Flateman ‘12) Neil Parikh T. Luke Sherwin Warby Parker (Andy Hunt ‘04) TeeSpring ( ‘11, ‘11) Walker Williams Evan Stites-Clayton Slideshare. ( ’98, Jonathan Boutelle ‘97) Rashmi Sinha Despite some of our alums raising over $100M for their startups and growing their teams in offices around the world, they still contribute heavily to the Brown community by offering advice and mentorship to current students and participating in conferences and workshops. If you’re interested in learning more about entrepreneurship@Brown, check out this recently released web hub, courtesy of Wesley Dencker ‘19 and the rest of the Tech team over at EP: _Entrepreneurship and Innovation at Brown and RISD_innovateonthehill.com Innovate on the Hill

he Startup Scene at Brown

As part of our , we examined the and libraries. The first of these allows you to create a database schema in a special syntax. You can then use Template Haskell to generate all the necessary Haskell data types and instances for your types. Even better, you can write Haskell code to query on these that resembles SQL. These queries are type-safe, which is awesome. However, the need to specify our schema with template Haskell presented some drawbacks. For instance, the code takes longer to compile and is less approachable for beginners. Haskell Web Series Persistent Esqueleto This week on the blog, we’ll be exploring another database library called . This library allows us to specify our database schema using Template Haskell. There’s some boilerplate involved, but it’s not bad at all! Like Persistent, Beam has support for many backends, such as SQLite and PostgresQL. Unlike Persistent, Beam also supports join queries as a built-in part of its system. Beam without For some more ideas on advanced libraries, be sure to check out our ! It includes a couple more different database options to look at. Production Checklist Specifying Our Types As a first note, while Beam doesn’t require Template Haskell, it does need a lot of other compiler extensions. You can look at those in the appendix below, or else take a look at the on Github. Now let’s think back to how we specified our schema when using Persistent: example code import qualified Database.Persist.TH as PTH

PTH.share [PTH.mkPersist PTH.sqlSettings, PTH.mkMigrate "migrateAll"] [PTH.persistLowerCase|  User sql=users    name Text    email Text    age Int    occupation Text    UniqueEmail email    deriving Show Read Eq

  Article sql=articles    title Text    body Text    publishedTime UTCTime    authorId UserId    UniqueTitle title    deriving Show Read Eq With Beam, we won’t use Template Haskell, so we’ll actually be creating normal Haskell data types. There will still be some oddities though. First, by convention, we’ll specify our types with the extra character at the end. This is unnecessary, but the convention helps us remember what types relate to tables. We'll also have to provide an extra type parameter , that we'll get into a bit more later: T f data UserT f =  …

data ArticleT f =  ... Our next convention will be to use an underscore in front of our field names. We will also, unlike Persistent, specify the type name in the field names. With these conventions, I’m following the advice of the library’s creator, Travis. data UserT f =  { _userId :: ...  , _userName :: …  , _userEmail :: …  , _userAge :: …  , _userOccupation :: …  }

data ArticleT f =  { _articleId :: …  , _articleTitle :: …  , _articleBody :: …  , _articlePublishedTime :: …  } So when we specify the actual types of each field, we’ll just put the relevant data type, like , or whatever, right? Well, not quite. To complete our types, we're going to fill in each field with the type we want, except specified via . Also, we'll derive on both of these types, which will allow Beam to work its magic: Int Text Columnar f Generic data UserT f =  { _userId :: Columnar f Int64  , _userName :: Columnar f Text  , _userEmail :: Columnar f Text  , _userAge :: Columnar f Int  , _userOccupation :: Columnar f Text  } deriving (Generic)

data ArticleT f =  { _articleId :: Columnar f Int64  , _articleTitle :: Columnar f Text  , _articleBody :: Columnar f Text  , _articlePublishedTime :: Columnar f Int64 -- Unix Epoch  } deriving (Generic) Now there are a couple small differences between this and our previous schema. First, we have the primary key as an explicit field of our type. With Persistent, we separated it using the abstraction. We'll see below how we can deal with situations where that key isn't known. The second difference is that (for now), we've left out the field on the article. We'll add this when we deal with primary keys. Entity userId Columnar So what exactly is this business about? Well under most circumstances, we'd like to specify a with the raw field types. But there are some situations where we'll have to use a more complicated type for an SQL expression. Let's start with the simple case first. Columnar User Luckily, works in such a way that if we use for , we can use raw types to fill in the field values. We'll make a type synonym specifically for this identity case. We can then make some examples: Columnar Identity f type User = UserT Identitytype Article = ArticleT Identity

user1 :: Useruser1 = User 1 "James" "james@example.com" 25 "programmer"

user2 :: Useruser2 = User 2 "Katie" "katie@example.com " 25 "engineer"

users :: [User]users = [ user1, user2 ] As a note, if you find it cumbersome to repeat the keyword, you can shorten it to : Columnar C data UserT f =  { _userId :: C f Int64  , _userName :: C f Text  , _userEmail :: C f Text  , _userAge :: C f Int  , _userOccupation :: C f Text  } deriving (Generic) Now, our initial examples will assign all our fields with raw values. So we won’t initially need to use anything for the parameter besides . Further down though, we'll deal with the case of auto-incrementing primary keys. In this case, we'll use the function, whose type is actually a Beam form of an SQL expression. In this case, we'll be using a different type for , but the flexibility will allow us to keep using our constructor! f Identity default_ f User Instances for our Types Now that we’ve specified our types, we can use the and type classes to tell Beam more about our types. Before we can make any of these types a , we'll want to assign its primary key type. So let's make a couple more type synonyms to represent these: Beamable Table Table type UserId = PrimaryKey UserT Identitytype ArticleId = PrimaryKey ArticleT Identity While we’re at it, let’s add that foreign key to our type: Article data ArticleT f =  { _articleId :: Columnar f Int64  , _articleTitle :: Columnar f Text  , _articleBody :: Columnar f Text  , _articlePublishedTime :: Columnar f Int64  , _articleUserId :: PrimaryKey UserT f  } deriving (Generic) We can now generate instances for both on our main types and on the primary key types. We'll also derive instances for and : Beamable Show Eq data UserT f =  …

deriving instance Show Userderiving instance Eq User

instance Beamable UserTinstance Beamable (PrimaryKey UserT)

data ArticleT f =  …

deriving instance Show Articlederiving instance Eq Article

instance Beamable ArticleTinstance Beamable (PrimaryKey ArticleT) Now we’ll create an instance for the class. This will involve some type family syntax. We'll specify and as our primary key data types. Then we can fill in the function to match up the right field. Table UserId ArticleId primaryKey instance Table UserT where  data PrimaryKey UserT f = UserId (Columnar f Int64) deriving Generic  primaryKey = UserId . _userId

instance Table ArticleT where  data PrimaryKey ArticleT f = ArticleId (Columnar f Int64) deriving Generic  primaryKey = ArticleId . _articleId Accessor Lenses We’ll do one more thing to mimic Persistent. The Template Haskell automatically generated lenses for us. We could use those when making database queries. Below, we’ll use something similar. But we’ll use a special function, , to make these rather than Template Haskell. If you remember back to how we used the library, we could create client functions by using and matching it against a pattern. We'll do something similar with . We'll use on each field of our tables, and create a pattern constructing an item. tableLenses Servant Client client tableLenses LensFor User  (LensFor userId)  (LensFor userName)  (LensFor userEmail)  (LensFor userAge)  (LensFor userOccupation) = tableLenses

Article  (LensFor articleId)  (LensFor articleTitle)  (LensFor articleBody)  (LensFor articlePublishedTime)  (UserId (LensFor articuleUserId)) = tableLenses Note we have to wrap the foreign key lens in . UserId Creating Our Database Now unlike Persistent, we’ll create an extra type that will represent our database. Each of our two tables will have a field within this database: data BlogDB f = BlogDB  { _blogUsers :: f (TableEntity UserT)  , _blogArticles :: f (TableEntity ArticleT)  } deriving (Generic) We’ll need to make our database type an instance of the class. We'll also specify a set of default settings we can use on our database. Both of these items will involve a parameter , which stands for a backend, (e.g. SQLite, Postgres). We leave this parameter generic for now. Database be instance Database be BlogDB

blogDb :: DatabaseSettings be BlogDBblogDb = defaultDbSettings Inserting Into Our Database Now, migrating our database with Beam is a little more complicated than it is with Persistent. We might cover that in a later article. For now, we’ll keep things simple, and use an SQLite database and migrate it ourselves. So let’s first create our tables. We have to follow Beam’s conventions here, particularly on the field for our foreign key: user_id__id CREATE TABLE users \  ( id INTEGER PRIMARY KEY AUTOINCREMENT\  , name VARCHAR NOT NULL \  , email VARCHAR NOT NULL \  , age INTEGER NOT NULL \  , occupation VARCHAR NOT NULL \  );CREATE TABLE articles \  ( id INTEGER PRIMARY KEY AUTOINCREMENT \  , title VARCHAR NOT NULL \  , body VARCHAR NOT NULL \  , published_time INTEGER NOT NULL \  , user_id__id INTEGER NOT NULL \  ); Now we want to write a couple queries that can interact with the database. Let’s start by inserting our raw users. We begin by opening up an SQLite connection, and we’ll write a function that uses this connection: import Database.SQLite.Simple (open, Connection)

main :: IO ()main = do  conn <- open "blogdb1.db"  insertUsers conn

insertUsers :: Connection -> IO ()insertUsers = ... We start our expression by using and passing the connection. Then we use to specify to Beam that we wish to make an insert statement. runBeamSqlite runInsert import Database.Beamimport Database.Beam.SQLite

insertUsers :: Connection -> IO ()insertUsers conn = runBeamSqlite conn $ runInsert $  ... Now we’ll use the function and signal which one of our tables we want out of our database: insert insertUsers :: Connection -> IO ()insertUsers conn = runBeamSqlite conn $ runInsert $  insert (_blogUsers blogDb) $ ... Last, since we are inserting raw values ( ), we use the function to complete this call: UserT Identity insertValues insertUsers :: Connection -> IO ()insertUsers conn = runBeamSqlite conn $ runInsert $  insert (_blogUsers blogDb) $ insertValues users And now we can check and verify that our users exist! SELECT * FROM users;1|James|james@example.com|25|programmer2|Katie|katie@example.com|25|engineer Let’s do the same for articles. We’ll use the function to access the primary key of a particular : pk User article1 :: Articlearticle1 = Article 1 "First article"   "A great article" 1531193221 (pk user1)

article2 :: Articlearticle2 = Article 2 "Second article"   "A better article" 1531199221 (pk user2)

article3 :: Articlearticle3 = Article 3 "Third article"   "The best article" 1531200221 (pk user1)

articles :: [Article]articles = [ article1, article2, article3]

insertArticles :: Connection -> IO ()insertArticles conn = runBeamSqlite conn $ runInsert $  insert (_blogArticles blogDb) $ insertValues articles Select Queries Now that we’ve inserted a couple elements, let’s run some basic select statements. In general for select, we’ll want the function. We could also query for a single element with a different function if we wanted: runSelectReturningList findUsers :: Connection -> IO ()findUsers conn = runBeamSqlite conn $ do  users <- runSelectReturningList $ ... Now we’ll use instead of from the last query. We'll also use the function on our users field in the database to signify that we want them all. And that's all we need!: select insert all_ findUsers :: Connection -> IO ()findUsers conn = runBeamSqlite conn $ do  users <- runSelectReturningList $ select (all_ (_blogUsers blogDb))  mapM_ (liftIO . putStrLn . show) users To do a filtered query, we’ll start with the same framework. But now we need to enhance our statement into a monadic expression. We'll start by selecting from all our users: select user findUsers :: Connection -> IO ()findUsers conn = runBeamSqlite conn $ do  users <- runSelectReturningList $ select $ do   user <- (all_ (_blogUsers blogDb))    ...  mapM_ (liftIO . putStrLn . show) users And we’ll now filter on that by using and applying one of our lenses. We use a operator for equality like in Persistent. We also have to wrap our raw comparison value with : guard_ ==. val findUsers :: Connection -> IO ()findUsers conn = runBeamSqlite conn $ do  users <- runSelectReturningList $ select $ do    user <- (all_ (_blogUsers blogDb))    guard_ (user ^. userName ==. (val_ "James"))    return user  mapM_ (liftIO . putStrLn . show) users And that’s all we need! Beam will generate the SQL for us! Now let’s try to do a join. This is actually much simpler in Beam than with Persistent/Esqueleto. All we need is to add a couple more statements to our “select” on the articles. We’ll just filter them by the user ID! findUsersAndArticles :: Connection -> IO ()findUsersAndArticles conn = runBeamSqlite conn $ do  users <- runSelectReturningList $ select $ do    user <- (all_ (_blogUsers blogDb))    guard_ (user ^. userName ==. (val_ "James"))    articles <- (all_ (_blogArticles blogDb))    guard_ (article ^. articleUserId ==. user ^. userId)    return user  mapM_ (liftIO . putStrLn . show) users That’s all there is to it! Auto-Incrementing Primary Keys In the examples above, we hard-coded all our IDs. But this isn’t typically what you want. We should let the database assign the ID via some rule, in our case auto-incrementing. In this case, instead of creating a "value", we'll make an "expression". This is possible through the polymorphic parameter in our type. We'll leave off the type signature since it's a bit confusing. But here's the expression we'll create: User f user1' = User  default_   (val_ "James")  (val_ "james@example.com")  (val_ 25)  (val_ "programmer") We use to represent an expression that will tell SQL to use a default value. Then we lift all our other values with . Finally, we'll use instead of in our Haskell expression. default_ val_ insertExpressions insertValues insertUsers :: Connection -> IO ()insertUsers conn = runBeamSqlite conn $ runInsert $  insert (_blogUsers blogDb) $ insertExpressions [ user1' ] Then we’ll have our auto-incrementing key! Conclusion That concludes our introduction to the library. As we saw, Beam is a great library that lets you specify a database schema without using any Template Haskell. For more details, make sure to check out the ! Beam documentation For a more in depth look at using Haskell libraries to make a web app, be sure to read our . It goes over some database mechanics as well as creating APIs and testing. As an added challenge, trying re-writing the code in that series to use Beam instead of Persistent. See how much of the code needs to change to accommodate that. Haskell Web Series Servant And for more examples of cool libraries, download our ! There are some more database and API libraries you can check out! Production Checklist APPENDIX: COMPILER EXTENSIONS {-# LANGUAGE DeriveGeneric #-}{-# LANGUAGE GADTs #-}{-# LANGUAGE OverloadedStrings #-}{-# LANGUAGE FlexibleContexts #-}{-# LANGUAGE FlexibleInstances #-}{-# LANGUAGE TypeFamilies #-}{-# LANGUAGE TypeApplications #-}{-# LANGUAGE StandaloneDeriving #-}{-# LANGUAGE TypeSynonymInstances #-}{-# LANGUAGE NoMonoMorphismRestriction #-}

Stories, News & Mentions about NOMNOM

Nomnom’s Stories on HackerNoon