Show HN: Pure browser side natural language processing https://ift.tt/2hUwCdS

Show HN: Pure browser side natural language processing https://winkjs.org/ May 5, 2023 at 09:45PM

Show HN: A search engine for your personal network of high-quality websites https://ift.tt/Jal4uRB

Show HN: A search engine for your personal network of high-quality websites Hey all, Last time when we were on HackerNews [1], we received a lot of feedback, and we incorporated most of it. - We have changed our name from grep.help to usegrasp.com - A privacy policy page - Bulk import - Pricing page We are happy to introduce a new feature: a personalized answer search engine that provides direct citations to the content on the page. Demo: https://ift.tt/ApBy2LH 1 - https://ift.tt/enzcJRX https://usegrasp.com May 5, 2023 at 01:34PM

Show HN: Text to Music – Create music and drum samples with AI https://ift.tt/fK72vNc

Show HN: Text to Music – Create music and drum samples with AI https://ift.tt/x24kwgl May 5, 2023 at 12:44PM

Show HN: Hypertune – Visual, functional, statically-typed configuration language https://ift.tt/YwA4ZSr

Show HN: Hypertune – Visual, functional, statically-typed configuration language Hey HN! I'm Miraan, the founder at Hypertune, and I'm excited to be posting this on HN. Hypertune lets you make your code configurable to let teammates like PMs and marketers quickly change feature flags, in-app copy, pricing plans, etc. It's like a CMS but instead of only letting you set static content, you can insert arbitrary logic from the UI, including A/B tests and ML "loops". I previously built a landing page optimization tool that let marketers define variants of their headline, CTA, cover image, etc, then used a genetic algorithm to find the best combination of them. They used my Chrome extension to define changes on DOM elements based on their unique CSS selector. But this broke when the underlying page changed and didn't work with sites that used CSS modules. Developers hated it. I took a step back. The problem I was trying to solve was making the page configurable by marketers in a way that developers liked. I decided to solve it from first principles and this led to Hypertune. Here's how it works. You define a strongly typed configuration schema in GraphQL, e.g. type Query { page(language: Language!, deviceType: DeviceType!): Page! } type Page { headline: String! imageUrl: String! showPromotion: Boolean! benefits: [String!]! } enum Language { English, French, Spanish } enum DeviceType { Desktop, Mobile, Tablet } Then marketers can configure these fields from the UI using our visual, functional, statically-typed language. The language UI is type-directed so we only show expression options that satisfy the required type of the hole in the logic tree. So for the "headline" field, you can insert a String expression or an If / Else expression that returns a String. If you insert the latter, more holes appear. This means marketers don't need to know any syntax and can't get into invalid states. They can use arguments you define in the schema like "language" and "deviceType", and drop A/B tests and contextual multi-armed bandits anywhere in their logic. We overlay live counts on the logic tree UI so they can see how often different branches are called. You get the config via our SDK which fetches your logic tree once on initialization (from our CDN) then evaluates it locally so you can get flags or content with different arguments (e.g. for different users) immediately with no network latency. So you can use the SDK on your backend without adding extra latency to every request, or on the frontend without blocking renders. The SDK includes a command line tool that auto-generates code for end-to-end type-safety based on your schema. You can also query your config via the GraphQL API. If you use the SDK, you can also embed a build-time snapshot of your logic tree in your app bundle. The SDK initializes from this instantly then fetches the latest logic from the server. So it'll still work in the unlikely event the CDN is down. And on the frontend, you can evaluate flags, content, A/B tests, personalization logic, etc, instantly on page load without any network latency, which makes it compatible with static Jamstack sites. I started building this for landing pages but realized it could be used for configuring feature flags, in-app content, translations, onboarding flows, permissions, rules, limits, magic numbers, pricing plans, backend services, cron jobs, etc, as it's all just "code configuration". This configuration is usually hardcoded, sprawled across json or yaml files, or in separate platforms for feature flags, content management, A/B testing, pricing plans, etc. So if a PM wants to A/B test new onboarding content, they need a developer to write glue code that stitches their A/B testing tool with their CMS for that specific test, then wait for a code deployment. And at that point, it may not be worth the effort. The general problem with having separate platforms is that all this configuration naturally overlaps. Feature flags and content management overlap with A/B testing and analytics. Pricing plans overlap with feature flags. Keeping them separate leads to inflexibility and duplication and requires hacky glue code, which defeats the purpose of configuration. I think the solution is a flexible, type-safe code configuration platform with a strongly typed schema, type-safe SDKs and APIs, and a visual, functional, statically-typed language with analytics, A/B testing and ML built in. I think this solves the problem with having separate platforms, but also results in a better solution for individual use cases and makes new use cases possible. For example, compared specifically to other feature flag platforms, you get auto-generated type-safe code to catch flag typos and errors at compile-time (instead of run-time), code completion and "find all references" in your IDE (no figuring out if a flag is in kebab-case or camelCase), type-safe enum flags you can exhaustively switch on, type-safe object and list flags, and a type-safe logic UI. You pass context arguments like userId, email, etc, in a type-safe way too with compiler errors if you miss or misspell one. To clean up a flag, you remove it from your query, re-run code generation and fix all the type errors to remove all references. The full programming language under the hood means there are no limits on your flag logic (you're not locked into basic disjunctive normal form). You can embed a build-time snapshot of your flag logic in your app bundle for guaranteed, instant initialization with no network latency (and keep this up to date with a commit webhook). And all your flags are versioned together in a single Git history for instant rollbacks to known good states (no figuring out what combination of flag changes caused an incident). There are other flexible configuration languages like Dhall (discussed here: https://ift.tt/mtuLMxk ), Jsonnet (discussed here: https://ift.tt/OHpt5wc ) and Cue (discussed here: https://ift.tt/pFmXYzG ). But they lack a UI for nontechnical users, can't be updated at run-time and don't support analytics, A/B testing and ML. I was actually going to start with a basic language that had primitives (Boolean, Int, String), a Comparison expression and an If / Else. Then users could implement the logic for each field in the schema separately. But then I realized they might want to share logic for a group of fields at the object level, e.g. instead of repeating "if (deviceType == Mobile) { primitiveA } else { primitiveB }" for each primitive field separately, they could have the logic once at the Page level: "if (deviceType == Mobile) { pageObjectA } else { pageObjectB }". I also needed to represent field arguments like "deviceType" in the language. And I realized users may want to define other variables to reuse bits of logic, like a specific "benefit" which appears in different variations of the "benefits" list. So at this point, it made sense to build a full, functional language with Object expressions (that have a type defined in the schema) and Function, Variable and Application expressions (to implement the lambda calculus). Then all the configuration can be represented as a single Object with the root Query type from the schema, e.g. Query { page: f({ deviceType }) => switch (true) { case (deviceType == DeviceType.Mobile) => Page { headline: f({}) => "Headline A" imageUrl: f({}) => "Image A" showPromotion: f({}) => true benefits: f({}) => ["Ben", "efits", "A"] } default => Page { headline: f({}) => "Headline B" imageUrl: f({}) => "Image B" showPromotion: f({}) => false benefits: f({}) => ["Ben", "efits", "B"] } } } So each schema field is implemented by a Function that takes a single Object parameter (a dictionary of field argument name => value). I needed to evaluate this logic tree given a GraphQL query that looks like: query { page(deviceType: Mobile) { headline showPromotion } } So I built an interpreter that recursively selects the queried parts of the logic tree, evaluating the Functions for each query field with the given arguments. It ignores fields that aren't in the query so the logic tree can grow large without affecting query performance. The interpreter is used by the SDK, to evaluate logic locally, and on our CDN edge server that hosts the GraphQL API. The response for the example above would be: { "__typename": "Query", "page": { "__typename": "Page", "headline": "Headline A", "showPromotion": true } } Developers were concerned about using the SDK on the frontend as it could leak sensitive configuration logic, like lists of user IDs, to the browser. To solve this, I modified the interpreter to support "partial evaluation". This is where it takes a GraphQL query that only provides some of the required field arguments and then partially evaluates the logic tree as much as possible. Any logic which can't be evaluated is left intact. The SDK can leverage this at initialization time by passing already known arguments (e.g. the user ID) in its initialization query so that sensitive logic (like lists of user IDs) are evaluated (and eliminated) on the server. The rest of the logic is evaluated locally by the SDK when client code calls its methods with the remaining arguments. This also minimizes the payload size sent to the client and means less logic needs to be evaluated locally, which improves both page load and render performance. The interpreter also keeps a count of expression evaluations as well as events for A/B tests and ML loops, which are flushed back to Hypertune in the background to overlay live analytics on the logic tree UI. It's been a challenge to build a simple UI given there's a full functional language under the hood. For example, I needed to build a way for users to convert any expression into a variable in one click. Under the hood, to make expression X a variable, we wrap the parent of X in a Function that takes a single parameter, then wrap that Function in an Application that passes X as an argument. Then we replace X in the Function body with a reference to the parameter. So we go from: if (X) { Y } else { Z } to ((paramX) => if (paramX) { Y } else { Z } )(X) So a variable is just an Application argument that can be referenced in the called Function's body. And once we have a variable, we can reference it in more than one place in the Function body. To undo this, users can "drop" a variable in one click which replaces all its references with a copy of its value. Converting X into a variable gets more tricky if the parent of X is a Function itself which defines parameters referenced inside of X. In this case, when we make X a variable, we lift it outside of this Function. But then it doesn't have access to the Function's parameters anymore. So we automatically convert X into a Function itself which takes the parameters it needs. Then we call this new Function where we originally had X, passing in the original parameters. There are more interesting details about how we lift variables to higher scopes in one click but that's for another post. Thanks for reading this far! I'm glad I got to share Hypertune with you. I'm curious about what use case appeals to you the most. Is it type-safe feature flags, in-app content management, A/B testing static Jamstack sites, managing permissions, pricing plans or something else? Please let me know any thoughts or questions! https://ift.tt/ma7CFWT May 4, 2023 at 08:31PM

Show HN: Low-level portfolio showcase projects beyond traditional CVs https://ift.tt/3XYOptc

Show HN: Low-level portfolio showcase projects beyond traditional CVs You are more than just your CV! I always feel that CVs are abbreviated and ATS-friendly but not human-friendly. I want to write about what inspired me beyond all my work. about my unique story and experiences that set me apart from the competition. it's important to make your resume ATS-friendly, don't forget to showcase the real you. Portfolio: https://ift.tt/oZS18jI... I appreciate any feedback or suggestions. https://ift.tt/Gk9SJVP May 5, 2023 at 07:13AM

Muni Rider Satisfaction the Highest in 10-years!

Muni Rider Satisfaction the Highest in 10-years!
By Bonnie Jean von Krogh

Here at the SFMTA, we are focused on creating the fastest, safest and most reliable public transportation network for all San Franciscans. This is why we consider it a top priority to hear from our riders and non-riders alike about how we’re doing, what your public transportation priorities are, and ways we can improve. These findings help to inform budget, long-range planning and policy decisions. They also help build a better Muni for everyone traveling in San Francisco. 

In recent months we conducted our Rider Survey as well as a broader Community Survey. Real-time data from our partners at Transit App in their North America Transit Rider Happiness Benchmarking Survey provides additional details about community feedback.  

The good news? Rider satisfaction with Muni services is up across the board: 

• Per SFMTA’s Rider survey, 66% of Muni riders rate services as good or excellent — a 9% increase from 2021. 
• The City Survey shows Muni’s rating at its highest level since 2013 
• Transit App’s survey shows Muni in the Top 5 North American cities when it comes to ranking riders most likely to recommend their public transit system to a friend 
• Transit App also shows that Muni riders give our drivers the highest overall approval rating across North America. Go, operators! 
• Finally, the Community Survey showcases that our riders have a much higher approval rating for the SFMTA than non-riders.  

So if you haven’t ridden Muni in a while, maybe it’s time to give it a try.   

 Highlights from the Community Survey

• 71% of riders approve of the SFMTA compared to  48% of non-riders. 
• 66% of riders rate Muni service as excellent/good compared to 48% of non-riders.   
• By 9 points, regular riders also consider Muni safer than non-riders 

Our Rider Survey shows us that customers have noticed the work Muni has been doing to address service delivery since the onset of the pandemic. Our ongoing investments in reliability improvements such as transit lanes, bus bulbs and smart traffic signals have also paid off. Over the last three years, we implemented over 21 miles of new transit lanes, bringing our transit lane network to more than 70 miles! With this expansion, Muni is quicker and more reliable than it has been in decades. 

That said, there’s more to be done, and respondents continue to emphasize “Improving the speed, frequency and reliability of Muni buses and trains,” with two-thirds of respondents prioritizing, “having the most frequent and reliable buses and trains, even if stops are more than 2 or 3 blocks away, rather than having closer stops.”  

Next Steps 

We asked what our community would most like to see changed, and while answers varied, the top priorities according to the Community Survey are:  

• Crime/safety (including fare evasion and passenger safety) 
• More reliable/efficient/on time service/less bunching of busses 
• Better communication and public outreach 
• Improved cleanliness of transit stops 
• Additional funding to create faster, safer and more reliable public transportation  

Safety is a Key Priority 

• Over 50% of respondents cited “Increasing safety from crime on Muni buses” as an extremely urgent priority. 
• Respondents answering the Community survey in Chinese had the strongest concern about safety. 58% of Chinese speakers consider Muni unsafe from crime, almost a full 20% higher than respondents to the survey in English. 
• The safety of our customers and staff is a top priority for the SFMTA. We have increased the number of staff riding Muni as a visual deterrent to crime. 
• We will continue our efforts to make sure all Muni riders are safe and can be confident riding our buses and trains and will update you with our progress.   

Increasing Reliability through Repairing and Upgrading our System 

•  A top priority of respondents is “Repairing and maintaining Muni equipment and facilities to ensure vehicles’ safety, frequency and reliability,” and our commitment to timely repair and maintenance work is in line with that.  
• Improving Real-Time Communications  
• Riders would like more reliable real-time communications to help with trip planning.  
• Improvements to the customer experience can be seen through the ongoing implementation of our new Next Generation Customer Information System.  

Respondents Understand the Need for Additional Public Transportation Funding  

• Finally, a key takeaway from the Community Survey is that respondents want a better and more reliable public transportation system and recognize the need for additional funding to accomplish our shared vision and goals.  
• Respondents support investing in Muni service as well as expanding safe bike and pedestrian pathways to ensure everyone in the city can access jobs and get where they need to go easily, regardless of their income or neighborhood.  

We agree that an affordable, reliable and safe public transit system is a critical part of a thriving and equitable community. We are committed to working toward this goal and thank our frontline staff for working so hard to improve service. 

Published May 05, 2023 at 12:41AM
https://ift.tt/DCVwYk1

Show HN: Skyname – the first Bluesky username registrar https://ift.tt/Z7qe1fn

Show HN: Skyname – the first Bluesky username registrar Hey HN! Skyname is the world's first Bluesky username registrar. Pick a fun domain from bsky.cool to tired.io and register your username in seconds. It'll automatically create the TXT record used for verification, assign it to your account, and update your handle on Bluesky. Interested to hear what y'all think :~) https://skyna.me May 4, 2023 at 10:20PM