CppCon 2015: Sean Parent "Better Code: Data Structures"

Sdílet
Vložit
  • čas přidán 28. 05. 2024
  • www.cppcon.org
    --
    The standard library containers are often both misused and underused. Instead of creating new containers, applications are often structured with incidental data structures composed of objects referencing other object. This talk looks at some of the ways the standard containers can be better utilized and how creating (or using non-standard library) containers can greatly simplify code. The goal is no incidental data structures.
    --
    Sean Parent is a principal scientist and software architect for Adobe’s mobile digital imaging group. Sean has been at Adobe since 1993 when he joined as a senior engineer working on Photoshop and later managed Adobe’s Software Technology Lab. In 2009 Sean spent a year at Google working on Chrome OS before returning to Adobe. From 1988 through 1993 Sean worked at Apple, where he was part of the system software team that developed the technologies allowing Apple’s successful transition to PowerPC.
    --
    Videos Filmed & Edited by Bash Films: www.BashFilms.com
    *-----*
    Register Now For CppCon 2022: cppcon.org/registration/
    *-----*

Komentáře • 48

  • @brainplot
    @brainplot Před 4 lety +14

    Sean Parent speaks so much like a professor/teacher. I love his tone and pace!

  • @DavidVaughan00
    @DavidVaughan00 Před 7 lety +53

    This is a really good talk; no idea what everybody below is complaining about. It's not even particularly slow compared to other talks.

    • @PatrickKellyLoneCoder
      @PatrickKellyLoneCoder Před 5 lety +7

      I really enjoy his speaking rate. Anyone who doesn't? That's why CZcams has playback rate adjustment. I use it to slow certain presenters, others can use it to speed him up.

  • @AllothTian
    @AllothTian Před 3 lety +2

    Great talk! The tree representation outlined in 44:25 looks like an Euler Tour Tree, introduced in 1984.

  • @bboysil
    @bboysil Před 2 lety +1

    This is one of the best talks I've heard in a while. you can put 1.5x or 1.25x if you think he speaks a pace that's too low for you.
    Love the statement at 20:50 . It's been something I've been arguing with big O notation puritans a while back.

    • @AG-ld6rv
      @AG-ld6rv Před 2 lety +2

      Just reference how std::sort for random access iterators uses an O(n^2) algorithm when the container is small enough.

  • @denzillong9878
    @denzillong9878 Před 8 lety +3

    Very well done. I really enjoyed this talk.

  • @danielhawkins3392
    @danielhawkins3392 Před 7 měsíci +1

    In the windows hierarchy example if a unique pointer was used instead of a shared that would make it a composite object no?
    This then makes class hierarchies perfectly fine. Am I missing something?

  • @EvgeniyZheltonozhskiy
    @EvgeniyZheltonozhskiy Před 8 lety

    Are there transcripts of CppCon videos somewhere?

  • @victornoagbodji
    @victornoagbodji Před 6 lety +2

    when are we going to have more chapters, can't wait lol : )

  • @scottmueller7700
    @scottmueller7700 Před 2 lety +8

    When the moon hits your eye like a big pizza pie, that's a rotate

  • @TheDuckofDoom.
    @TheDuckofDoom. Před 6 lety +3

    Does this book exist yet?

  • @Skyganli
    @Skyganli Před 7 lety +13

    'Let us form some happy little algorithms, okay?'

  • @rocknroooollllll
    @rocknroooollllll Před 2 lety

    Just chiming in against the "too slow" complaints. I prefer the considered approach; x10000000 better than _some_ talks where they haave death by powerpoint (too many slides) and so much to say that they say, "Comments and questions at the end, please". Often, they never get to the end. Just compare this talk to any Lakos talk. Heaven!

  • @nelsondavenapalli8802
    @nelsondavenapalli8802 Před 8 lety

    Great insights shared by Sean Parent. Must watch

  • @leonhrad
    @leonhrad Před 8 lety +11

    11:17 What if I told you 4 is actually greater than 3?

    • @scottmueller7700
      @scottmueller7700 Před 2 lety

      It's funny because we don't use greater-than in standard library predicates, it's always less-than to define well-ordering.

  • @jankodedic3130
    @jankodedic3130 Před 6 lety +15

    The talk is exactly 64 min long.

  • @m13m
    @m13m Před 6 lety +1

    Sean what a speaker beautiful

  • @warrenhenning8064
    @warrenhenning8064 Před 3 lety +5

    How about he uses some of these good data structures on Photoshop so that it doesn't take forever to load when it doesn't do any work that's useful to the user on startup?

  • @alexandersedykh9280
    @alexandersedykh9280 Před 2 lety

    What is the trailing_of_begin() 51:05? Hm. Apple's UIKit has Window 'Hierarchy' and detect a tap by pass the tap down through the hierarchy

    • @SeanParent
      @SeanParent Před 2 lety

      Each node has two in-edges, leading (in the picture left side pointing down), and trailing (right side pointing up). `begin(f)` points to the leading edge of `A`. `trailing_of(begin(f))` returns an iterator pointing to the trailing edge of `A`. After inserting `B, C, D` the result is the image shown.

  •  Před 8 lety +1

    Would have been clearer with more code examples. Like the do's and don't's. But perhaps I'm just too tired for my brain to work properly.

  • @QuentinUK
    @QuentinUK Před 8 lety

    Digital Imaging.
    +Evgeniy Zheltonozhskiy Transcripts are under ". . . More".

  • @Radrik05
    @Radrik05 Před 5 lety

    At 21:00 log 1'000'000'000'000 = 40 tests (in search) each of these is 200 times slower than cache-friendly linear test. So 8'000 is faster then 500'000'000'000 (average number of tests in linear search). Big O notation does make sense or I didn't get the idea of the example.

    • @sebastianmestre8971
      @sebastianmestre8971 Před 5 lety +6

      He meant that a cache friendly nlogn algorithm might run faster than a non cache friendly linear algorithm
      linear, cache unfriendly (200x comes from slow memory access)
      1'000'000'000'000 * 200 = 200'000'000'000'000
      linearithmic, cache friendly (40x comes from the log factor)
      1'000'000'000'000 * 40 = 40'000'000'000'000
      200'000'000'000'000 / 40'000'000'000'000 = 20 (nlogn could end up being 20 times faster)
      (or just 10 times faster on average)

  • @batner
    @batner Před 7 lety +7

    So I feel a bit dumb after watching this. I did understand most of his ideas but up to a point in each case. Something gives up in my brain and i lose the feeling of comprehensive understanding.

    • @MM-24
      @MM-24 Před 7 lety

      Yea his use of vocabulary was a bit bothersome in some places. I'll have to re-watch with google in another tab ... will be good thing however and bring me to another level though

    • @JaihindhReddy
      @JaihindhReddy Před 7 lety +2

      Rewatch at 1.5x. You'll be surprised.

    • @aperson4051
      @aperson4051 Před 4 lety

      Reassuring I'm not the only one. Constantly feeling alittle bit stupid

    • @AG-ld6rv
      @AG-ld6rv Před 2 lety +1

      These types of things aren't understood for free. He has done as he recommends, so he has dedicated hours into thinking about STL algorithms and their implementations. He also references an entire book he has carefully read as the source of many concepts he brought up. People often see a challenge and give up if things don't immediately click. The only way to be like him is through hard work. Many people who picked up programming on its own never studied data structures and algorithms for hours. I'd recommend getting an introductory book on those topics and diving right in if you are one of these people. It takes a good chunk of time and effort.

  • @shenzi1118
    @shenzi1118 Před 4 lety +7

    tl;dr use vector for everything.

  • @VictorChavesVVBC
    @VictorChavesVVBC Před 8 lety +3

    I liked this talk, but apparently this goes against many well stablished and useful Design Patterns. Self-referential classes are really nice sometimes and I think we should not make an explicit effort to not use it when the abstract model of the problems is clearly self referential.

  • @leonid998
    @leonid998 Před 2 lety

    19:33 accidentally lookup in a map became n*log(n)

  • @lobetrotter
    @lobetrotter Před 5 lety +1

    zZZZZZZZZZZZZZZ

  • @dniam9859
    @dniam9859 Před 5 lety

    ok?

  • @matthew21995
    @matthew21995 Před 8 lety +9

    is this guys in on slow motion? lol

    • @MM-24
      @MM-24 Před 7 lety +4

      Pro Tip - use CZcamss 2x speedup .... I can't watch any talks without it

    • @TheClonerx
      @TheClonerx Před 6 lety

      M M pro tip: you can't in mobile

    • @xthebumpx
      @xthebumpx Před 6 lety +1

      My favorite part is where he says he must have talked faster than he was expecting to.

    • @alienwarem18x
      @alienwarem18x Před 6 lety +3

      Now you can

  • @thetdltornike
    @thetdltornike Před 8 lety +16

    watched it at 2x speed, still too slow

  • @TheCriticFromSouth
    @TheCriticFromSouth Před 7 lety +4

    And this, boys and girls, is what happens when you are given 1 hour to talk and you have (if you have) only 30 minutes of topic to fill.

    • @matthewharris6454
      @matthewharris6454 Před 2 lety +2

      And this, boys and girls, is what happens when you have nothing to say but you make a comment saying it anyway

  • @rg3412
    @rg3412 Před 6 lety +3

    God that guy loves to listen to himself

    • @AG-ld6rv
      @AG-ld6rv Před 2 lety +2

      Your perspective is bizarre. He most likely makes a million or more a year programming. His viewpoint that he has developed over decades from real-world experience, reading books, studying code beyond what he needed, etc. is both highly valuable and justified. In a situation like this, people jealously associate success from hard work with stuff like arrogance. Sometimes, a person just knows what they are talking about.

  • @tw7522
    @tw7522 Před 8 lety +7

    Terribly slow and exhausting.