Alish Sharma, Software Engineer

1import { NextResponse } from "next/server";
2import { createClient } from "@/lib/supabase";
3
4export async function POST(req: Request) {
5  const { address, service, window } = await req.json();
6  const db = createClient();
7  const { data, error } = await db
8    .from("jobs")
9    .insert({ address, service, window, status: "open" })
10    .select()
11    .single();
12  if (error) return NextResponse.json(error, { status: 400 });
13  return NextResponse.json(data, { status: 201 });
14}

18struct JobCard: View {
19  let job: Job
20  @State private var accepted = false
21
22  var body: some View {
23    VStack(alignment: .leading, spacing: 8) {
24      Text(job.service.title).font(.headline)
25      Label(job.address, systemImage: "mappin")
26      Button(accepted ? "Accepted" : "Accept job") {
27        withAnimation(.spring) { accepted = true }
28      }
29      .buttonStyle(.borderedProminent)
30    }
31    .padding()
32  }
33}

37void OrderBook::match(Order& in, Fills& out) {
38  auto& side = in.side == Side::Buy ? asks_ : bids_;
39  while (in.qty > 0 && !side.empty()) {
40    Level& best = side.best();
41    if (!crosses(in, best.price)) break;
42    Order& rest = best.front();
43    const Qty q = std::min(in.qty, rest.qty);
44    out.push_back({rest.id, in.id, best.price, q});
45    in.qty -= q;
46    rest.qty -= q;
47    if (rest.qty == 0) best.pop_front();
48    if (best.empty()) side.erase_best();
49  }
50}

54import heapq
55
56def dijkstra(graph, src):
57    dist = {node: float("inf") for node in graph}
58    dist[src] = 0
59    pq = [(0, src)]
60    while pq:
61        d, u = heapq.heappop(pq)
62        if d > dist[u]:
63            continue
64        for v, w in graph[u]:
65            if d + w < dist[v]:
66                dist[v] = d + w
67                heapq.heappush(pq, (dist[v], v))
68    return dist

72create table payouts (
73  id uuid primary key default gen_random_uuid(),
74  provider_id uuid references providers(id),
75  job_id uuid references jobs(id) on delete cascade,
76  amount_cents integer not null check (amount_cents > 0),
77  stripe_transfer text unique,
78  created_at timestamptz default now()
79);
80
81create index payouts_provider_idx
82  on payouts (provider_id, created_at desc);

86$ npm run build
87▲ Next.js 16
88  Creating an optimized production build ...
89✓ Compiled successfully
90✓ Generating static pages (9/9)
91Route (app)              Size
92┌ ○ /                    12.4 kB
93├ ○ /about                6.1 kB
94└ ● /projects/[slug]      4.8 kB
95$ git push origin main

99export function Magnetic({ children }: Props) {
100  const ref = useRef<HTMLDivElement>(null);
101  useGSAP(() => {
102    const x = gsap.quickTo(ref.current, "x", { ease: "power3" });
103    const y = gsap.quickTo(ref.current, "y", { ease: "power3" });
104    const move = (e: PointerEvent) => {
105      const r = ref.current!.getBoundingClientRect();
106      x((e.clientX - r.left - r.width / 2) * 0.35);
107      y((e.clientY - r.top - r.height / 2) * 0.35);
108    };
109    ref.current!.addEventListener("pointermove", move);
110  });
111  return <div ref={ref}>{children}</div>;
112}

116// marching squares — 16 cases, linear interpolation
117for (let y = 0; y < rows; y++) {
118  for (let x = 0; x < cols; x++) {
119    const a = f[i], b = f[i + 1];
120    const c = f[i + cols + 1], d = f[i + cols];
121    const k = (a > lvl ? 8 : 0) | (b > lvl ? 4 : 0)
122            | (c > lvl ? 2 : 0) | (d > lvl ? 1 : 0);
123    if (k === 0 || k === 15) continue;
124    segment(k, lerp(a, b, lvl), lerp(b, c, lvl));
125  }
126}

130class Kalman:
131    def predict(self):
132        self.x = self.F @ self.x
133        self.P = self.F @ self.P @ self.F.T + self.Q
134        return self.x[:4]
135
136    def update(self, z):
137        y = z - self.H @ self.x
138        S = self.H @ self.P @ self.H.T + self.R
139        K = self.P @ self.H.T @ np.linalg.inv(S)
140        self.x = self.x + K @ y
141        self.P = (self.I - K @ self.H) @ self.P

145const event = stripe.webhooks.constructEvent(
146  body, signature, process.env.STRIPE_WEBHOOK_SECRET!
147);
148
149switch (event.type) {
150  case "payment_intent.succeeded":
151    await markJobPaid(event.data.object.metadata.jobId);
152    break;
153  case "account.updated":
154    await syncProvider(event.data.object);
155    break;
156}

160export function useScrollProgress(target) {
161  const [p, setP] = useState(0);
162  useEffect(() => {
163    const st = ScrollTrigger.create({
164      trigger: target.current,
165      start: "top bottom",
166      end: "bottom top",
167      onUpdate: (self) => setP(self.progress),
168    });
169    return () => st.kill();
170  }, [target]);
171  return p;
172}

176func search<T: Comparable>(_ a: [T], _ key: T) -> Int? {
177  var lo = 0, hi = a.count - 1
178  while lo <= hi {
179    let mid = lo + (hi - lo) / 2
180    if a[mid] == key { return mid }
181    if a[mid] < key { lo = mid + 1 } else { hi = mid - 1 }
182  }
183  return nil
184}

188from ipaddress import ip_network
189
190net = ip_network("10.20.0.0/22")
191for sub in net.subnets(new_prefix=24):
192    hosts = sub.num_addresses - 2
193    print(f"{sub}  gw={sub[1]}  hosts={hosts}")
194
195# 10.20.0.0/24  gw=10.20.0.1  hosts=254
196# 10.20.1.0/24  gw=10.20.1.1  hosts=254

200select p.id, p.name,
201       count(j.id) as jobs_done,
202       round(avg(r.stars), 2) as rating
203from providers p
204left join jobs j on j.provider_id = p.id
205  and j.status = 'complete'
206left join reviews r on r.job_id = j.id
207group by p.id
208order by rating desc nulls last
209limit 20;

213export default function Hero() {
214  return (
215    <section className="relative h-svh">
216      <ContourBackground />
217      <CodeRevealLens radius={48} />
218      <h1 className="display">
219        <span>Alish</span>
220        <span>Sharma</span>
221      </h1>
222      <HeroPortrait src="/images/alish-headshot.png" />
223    </section>
224  );
225}

229@app.post("/diagnose")
230async def diagnose(photo: UploadFile):
231    image = await load_image(photo)
232    findings = model.predict(image, conf=0.4)
233    return {
234        "issues": [f.label for f in findings],
235        "steps": guide.for_issues(findings),
236    }

240class LRU<K, V> {
241  private map = new Map<K, V>();
242  constructor(private cap: number) {}
243  get(k: K) {
244    if (!this.map.has(k)) return undefined;
245    const v = this.map.get(k)!;
246    this.map.delete(k); this.map.set(k, v);
247    return v;
248  }
249  set(k: K, v: V) {
250    this.map.delete(k); this.map.set(k, v);
251    if (this.map.size > this.cap)
252      this.map.delete(this.map.keys().next().value!);
253  }
254}

258gsap.timeline({
259  scrollTrigger: {
260    trigger: ".work",
261    pin: true,
262    scrub: 1,
263    end: () => "+=" + track.scrollWidth,
264  },
265}).to(track, {
266  x: () => -(track.scrollWidth - innerWidth),
267  ease: "none",
268});

272// marching squares — 16 cases, linear interpolation
273for (let y = 0; y < rows; y++) {
274  for (let x = 0; x < cols; x++) {
275    const a = f[i], b = f[i + 1];
276    const c = f[i + cols + 1], d = f[i + cols];
277    const k = (a > lvl ? 8 : 0) | (b > lvl ? 4 : 0)
278            | (c > lvl ? 2 : 0) | (d > lvl ? 1 : 0);
279    if (k === 0 || k === 15) continue;
280    segment(k, lerp(a, b, lvl), lerp(b, c, lvl));
281  }
282}

286class Kalman:
287    def predict(self):
288        self.x = self.F @ self.x
289        self.P = self.F @ self.P @ self.F.T + self.Q
290        return self.x[:4]
291
292    def update(self, z):
293        y = z - self.H @ self.x
294        S = self.H @ self.P @ self.H.T + self.R
295        K = self.P @ self.H.T @ np.linalg.inv(S)
296        self.x = self.x + K @ y
297        self.P = (self.I - K @ self.H) @ self.P

301const event = stripe.webhooks.constructEvent(
302  body, signature, process.env.STRIPE_WEBHOOK_SECRET!
303);
304
305switch (event.type) {
306  case "payment_intent.succeeded":
307    await markJobPaid(event.data.object.metadata.jobId);
308    break;
309  case "account.updated":
310    await syncProvider(event.data.object);
311    break;
312}

316export function useScrollProgress(target) {
317  const [p, setP] = useState(0);
318  useEffect(() => {
319    const st = ScrollTrigger.create({
320      trigger: target.current,
321      start: "top bottom",
322      end: "bottom top",
323      onUpdate: (self) => setP(self.progress),
324    });
325    return () => st.kill();
326  }, [target]);
327  return p;
328}

332func search<T: Comparable>(_ a: [T], _ key: T) -> Int? {
333  var lo = 0, hi = a.count - 1
334  while lo <= hi {
335    let mid = lo + (hi - lo) / 2
336    if a[mid] == key { return mid }
337    if a[mid] < key { lo = mid + 1 } else { hi = mid - 1 }
338  }
339  return nil
340}

344from ipaddress import ip_network
345
346net = ip_network("10.20.0.0/22")
347for sub in net.subnets(new_prefix=24):
348    hosts = sub.num_addresses - 2
349    print(f"{sub}  gw={sub[1]}  hosts={hosts}")
350
351# 10.20.0.0/24  gw=10.20.0.1  hosts=254
352# 10.20.1.0/24  gw=10.20.1.1  hosts=254

356select p.id, p.name,
357       count(j.id) as jobs_done,
358       round(avg(r.stars), 2) as rating
359from providers p
360left join jobs j on j.provider_id = p.id
361  and j.status = 'complete'
362left join reviews r on r.job_id = j.id
363group by p.id
364order by rating desc nulls last
365limit 20;

369export default function Hero() {
370  return (
371    <section className="relative h-svh">
372      <ContourBackground />
373      <CodeRevealLens radius={48} />
374      <h1 className="display">
375        <span>Alish</span>
376        <span>Sharma</span>
377      </h1>
378      <HeroPortrait src="/images/alish-headshot.png" />
379    </section>
380  );
381}

385@app.post("/diagnose")
386async def diagnose(photo: UploadFile):
387    image = await load_image(photo)
388    findings = model.predict(image, conf=0.4)
389    return {
390        "issues": [f.label for f in findings],
391        "steps": guide.for_issues(findings),
392    }

396class LRU<K, V> {
397  private map = new Map<K, V>();
398  constructor(private cap: number) {}
399  get(k: K) {
400    if (!this.map.has(k)) return undefined;
401    const v = this.map.get(k)!;
402    this.map.delete(k); this.map.set(k, v);
403    return v;
404  }
405  set(k: K, v: V) {
406    this.map.delete(k); this.map.set(k, v);
407    if (this.map.size > this.cap)
408      this.map.delete(this.map.keys().next().value!);
409  }
410}

414gsap.timeline({
415  scrollTrigger: {
416    trigger: ".work",
417    pin: true,
418    scrub: 1,
419    end: () => "+=" + track.scrollWidth,
420  },
421}).to(track, {
422  x: () => -(track.scrollWidth - innerWidth),
423  ease: "none",
424});

428import { NextResponse } from "next/server";
429import { createClient } from "@/lib/supabase";
430
431export async function POST(req: Request) {
432  const { address, service, window } = await req.json();
433  const db = createClient();
434  const { data, error } = await db
435    .from("jobs")
436    .insert({ address, service, window, status: "open" })
437    .select()
438    .single();
439  if (error) return NextResponse.json(error, { status: 400 });
440  return NextResponse.json(data, { status: 201 });
441}

445struct JobCard: View {
446  let job: Job
447  @State private var accepted = false
448
449  var body: some View {
450    VStack(alignment: .leading, spacing: 8) {
451      Text(job.service.title).font(.headline)
452      Label(job.address, systemImage: "mappin")
453      Button(accepted ? "Accepted" : "Accept job") {
454        withAnimation(.spring) { accepted = true }
455      }
456      .buttonStyle(.borderedProminent)
457    }
458    .padding()
459  }
460}

464void OrderBook::match(Order& in, Fills& out) {
465  auto& side = in.side == Side::Buy ? asks_ : bids_;
466  while (in.qty > 0 && !side.empty()) {
467    Level& best = side.best();
468    if (!crosses(in, best.price)) break;
469    Order& rest = best.front();
470    const Qty q = std::min(in.qty, rest.qty);
471    out.push_back({rest.id, in.id, best.price, q});
472    in.qty -= q;
473    rest.qty -= q;
474    if (rest.qty == 0) best.pop_front();
475    if (best.empty()) side.erase_best();
476  }
477}

481import heapq
482
483def dijkstra(graph, src):
484    dist = {node: float("inf") for node in graph}
485    dist[src] = 0
486    pq = [(0, src)]
487    while pq:
488        d, u = heapq.heappop(pq)
489        if d > dist[u]:
490            continue
491        for v, w in graph[u]:
492            if d + w < dist[v]:
493                dist[v] = d + w
494                heapq.heappush(pq, (dist[v], v))
495    return dist

499create table payouts (
500  id uuid primary key default gen_random_uuid(),
501  provider_id uuid references providers(id),
502  job_id uuid references jobs(id) on delete cascade,
503  amount_cents integer not null check (amount_cents > 0),
504  stripe_transfer text unique,
505  created_at timestamptz default now()
506);
507
508create index payouts_provider_idx
509  on payouts (provider_id, created_at desc);

513$ npm run build
514▲ Next.js 16
515  Creating an optimized production build ...
516✓ Compiled successfully
517✓ Generating static pages (9/9)
518Route (app)              Size
519┌ ○ /                    12.4 kB
520├ ○ /about                6.1 kB
521└ ● /projects/[slug]      4.8 kB
522$ git push origin main

526export function Magnetic({ children }: Props) {
527  const ref = useRef<HTMLDivElement>(null);
528  useGSAP(() => {
529    const x = gsap.quickTo(ref.current, "x", { ease: "power3" });
530    const y = gsap.quickTo(ref.current, "y", { ease: "power3" });
531    const move = (e: PointerEvent) => {
532      const r = ref.current!.getBoundingClientRect();
533      x((e.clientX - r.left - r.width / 2) * 0.35);
534      y((e.clientY - r.top - r.height / 2) * 0.35);
535    };
536    ref.current!.addEventListener("pointermove", move);
537  });
538  return <div ref={ref}>{children}</div>;
539}

543func search<T: Comparable>(_ a: [T], _ key: T) -> Int? {
544  var lo = 0, hi = a.count - 1
545  while lo <= hi {
546    let mid = lo + (hi - lo) / 2
547    if a[mid] == key { return mid }
548    if a[mid] < key { lo = mid + 1 } else { hi = mid - 1 }
549  }
550  return nil
551}

555from ipaddress import ip_network
556
557net = ip_network("10.20.0.0/22")
558for sub in net.subnets(new_prefix=24):
559    hosts = sub.num_addresses - 2
560    print(f"{sub}  gw={sub[1]}  hosts={hosts}")
561
562# 10.20.0.0/24  gw=10.20.0.1  hosts=254
563# 10.20.1.0/24  gw=10.20.1.1  hosts=254

567select p.id, p.name,
568       count(j.id) as jobs_done,
569       round(avg(r.stars), 2) as rating
570from providers p
571left join jobs j on j.provider_id = p.id
572  and j.status = 'complete'
573left join reviews r on r.job_id = j.id
574group by p.id
575order by rating desc nulls last
576limit 20;

580export default function Hero() {
581  return (
582    <section className="relative h-svh">
583      <ContourBackground />
584      <CodeRevealLens radius={48} />
585      <h1 className="display">
586        <span>Alish</span>
587        <span>Sharma</span>
588      </h1>
589      <HeroPortrait src="/images/alish-headshot.png" />
590    </section>
591  );
592}

596@app.post("/diagnose")
597async def diagnose(photo: UploadFile):
598    image = await load_image(photo)
599    findings = model.predict(image, conf=0.4)
600    return {
601        "issues": [f.label for f in findings],
602        "steps": guide.for_issues(findings),
603    }

607class LRU<K, V> {
608  private map = new Map<K, V>();
609  constructor(private cap: number) {}
610  get(k: K) {
611    if (!this.map.has(k)) return undefined;
612    const v = this.map.get(k)!;
613    this.map.delete(k); this.map.set(k, v);
614    return v;
615  }
616  set(k: K, v: V) {
617    this.map.delete(k); this.map.set(k, v);
618    if (this.map.size > this.cap)
619      this.map.delete(this.map.keys().next().value!);
620  }
621}

625gsap.timeline({
626  scrollTrigger: {
627    trigger: ".work",
628    pin: true,
629    scrub: 1,
630    end: () => "+=" + track.scrollWidth,
631  },
632}).to(track, {
633  x: () => -(track.scrollWidth - innerWidth),
634  ease: "none",
635});

639import { NextResponse } from "next/server";
640import { createClient } from "@/lib/supabase";
641
642export async function POST(req: Request) {
643  const { address, service, window } = await req.json();
644  const db = createClient();
645  const { data, error } = await db
646    .from("jobs")
647    .insert({ address, service, window, status: "open" })
648    .select()
649    .single();
650  if (error) return NextResponse.json(error, { status: 400 });
651  return NextResponse.json(data, { status: 201 });
652}

656struct JobCard: View {
657  let job: Job
658  @State private var accepted = false
659
660  var body: some View {
661    VStack(alignment: .leading, spacing: 8) {
662      Text(job.service.title).font(.headline)
663      Label(job.address, systemImage: "mappin")
664      Button(accepted ? "Accepted" : "Accept job") {
665        withAnimation(.spring) { accepted = true }
666      }
667      .buttonStyle(.borderedProminent)
668    }
669    .padding()
670  }
671}

675void OrderBook::match(Order& in, Fills& out) {
676  auto& side = in.side == Side::Buy ? asks_ : bids_;
677  while (in.qty > 0 && !side.empty()) {
678    Level& best = side.best();
679    if (!crosses(in, best.price)) break;
680    Order& rest = best.front();
681    const Qty q = std::min(in.qty, rest.qty);
682    out.push_back({rest.id, in.id, best.price, q});
683    in.qty -= q;
684    rest.qty -= q;
685    if (rest.qty == 0) best.pop_front();
686    if (best.empty()) side.erase_best();
687  }
688}

692import heapq
693
694def dijkstra(graph, src):
695    dist = {node: float("inf") for node in graph}
696    dist[src] = 0
697    pq = [(0, src)]
698    while pq:
699        d, u = heapq.heappop(pq)
700        if d > dist[u]:
701            continue
702        for v, w in graph[u]:
703            if d + w < dist[v]:
704                dist[v] = d + w
705                heapq.heappush(pq, (dist[v], v))
706    return dist

710create table payouts (
711  id uuid primary key default gen_random_uuid(),
712  provider_id uuid references providers(id),
713  job_id uuid references jobs(id) on delete cascade,
714  amount_cents integer not null check (amount_cents > 0),
715  stripe_transfer text unique,
716  created_at timestamptz default now()
717);
718
719create index payouts_provider_idx
720  on payouts (provider_id, created_at desc);

724$ npm run build
725▲ Next.js 16
726  Creating an optimized production build ...
727✓ Compiled successfully
728✓ Generating static pages (9/9)
729Route (app)              Size
730┌ ○ /                    12.4 kB
731├ ○ /about                6.1 kB
732└ ● /projects/[slug]      4.8 kB
733$ git push origin main

737export function Magnetic({ children }: Props) {
738  const ref = useRef<HTMLDivElement>(null);
739  useGSAP(() => {
740    const x = gsap.quickTo(ref.current, "x", { ease: "power3" });
741    const y = gsap.quickTo(ref.current, "y", { ease: "power3" });
742    const move = (e: PointerEvent) => {
743      const r = ref.current!.getBoundingClientRect();
744      x((e.clientX - r.left - r.width / 2) * 0.35);
745      y((e.clientY - r.top - r.height / 2) * 0.35);
746    };
747    ref.current!.addEventListener("pointermove", move);
748  });
749  return <div ref={ref}>{children}</div>;
750}

754// marching squares — 16 cases, linear interpolation
755for (let y = 0; y < rows; y++) {
756  for (let x = 0; x < cols; x++) {
757    const a = f[i], b = f[i + 1];
758    const c = f[i + cols + 1], d = f[i + cols];
759    const k = (a > lvl ? 8 : 0) | (b > lvl ? 4 : 0)
760            | (c > lvl ? 2 : 0) | (d > lvl ? 1 : 0);
761    if (k === 0 || k === 15) continue;
762    segment(k, lerp(a, b, lvl), lerp(b, c, lvl));
763  }
764}

768class Kalman:
769    def predict(self):
770        self.x = self.F @ self.x
771        self.P = self.F @ self.P @ self.F.T + self.Q
772        return self.x[:4]
773
774    def update(self, z):
775        y = z - self.H @ self.x
776        S = self.H @ self.P @ self.H.T + self.R
777        K = self.P @ self.H.T @ np.linalg.inv(S)
778        self.x = self.x + K @ y
779        self.P = (self.I - K @ self.H) @ self.P

783const event = stripe.webhooks.constructEvent(
784  body, signature, process.env.STRIPE_WEBHOOK_SECRET!
785);
786
787switch (event.type) {
788  case "payment_intent.succeeded":
789    await markJobPaid(event.data.object.metadata.jobId);
790    break;
791  case "account.updated":
792    await syncProvider(event.data.object);
793    break;
794}

798export function useScrollProgress(target) {
799  const [p, setP] = useState(0);
800  useEffect(() => {
801    const st = ScrollTrigger.create({
802      trigger: target.current,
803      start: "top bottom",
804      end: "bottom top",
805      onUpdate: (self) => setP(self.progress),
806    });
807    return () => st.kill();
808  }, [target]);
809  return p;
810}