3 ms·
Curious what boilerplate is common in C++ that isn’t needed in Swift. I find the repetitive boilerplate level of C++ pretty minimal, especially compared to lan
by gumby 4y ago
Curious what boilerplate is common in C++ that isn’t needed in Swift. I find the repetitive boilerplate level of C++ pretty minimal, especially compared to languages like Java.
Template specification used to need a lot of decoration but with auto most of that is gone.
- jcelerier 4y agoif the code started in the 80s, I doubt there's many autos or templates
- unnouinceput 4y agoThat makes 2 of us. When I've read "So much of the repetitive boilerplate code that was necessary for C++ melted away in Swift" my eyes rolled over. For me Swift repetitive boilerplate is on par with the one in C++. Clearly the author never touched Ada nor Python, if that's the number one reason he wanted another language to eliminate the repetitive boilerplate. I suspect he just wanted to learn Swift and that's a good reason enough to make this rewrite, as he admits in the final paragraphs of the article: "I’ve enjoyed learning Swift and am much happier with the state of the code now"
- heavyset_go 4y agoOld code is going to have long implementations of things we take for granted now.
- tomovo 4y agoHeaders? Awkward string manipulation? Very thin standard library? Fragmented build systems? I would describe dealing with those issues as "boilerplate" because it's just a lot of code you should not have to write. Swift is so much more comfortable and fun. (btw I still love C++ and cross platform support completely flips the script)
- _gabe_ 4y ago> Very thin standard library? I'm not sure we're thinking of the same standard library if you would describe it as thin...[0] [0]: https://docs.microsoft.com/en-us/cpp/standard-library/cpp-standard-library-header-files?view=msvc-170 https://docs.microsoft.com/en-us/cpp/standard-library/cpp-st...
- lifthrasiir 4y agoThat is still thin by the modern standard. More accurately speaking, C++ standard library has too many useless things and lacks too many useful things. Compare with D [1], Rust [2] or Zig [3]. [1] https://dlang.org/phobos/ https://dlang.org/phobos/ [2] https://doc.rust-lang.org/std/ https://doc.rust-lang.org/std/ [3] https://ziglang.org/documentation/master/std/ https://ziglang.org/documentation/master/std/
- _gabe_ 4y agoIt looks like the only big feature any of these standard libraries contain that C++ doesn't are things like networking and json/xml parsers. I would argue that those should not be part of a standard library, but you can still easily get those through additional C/C++ libraries. I honestly don't know what else you would be looking for in a standard library. C++ provides out of the box: - hash maps - sets - dynamic arrays - fixed length arrays - bit sets - option types - atomics - mutexes - futures - strings - queues/stacks/Deques - tuples - variants - streams - etc In addition, they have a huge range of algorithms that operate on all of these containers. I'm really curious, what does the standard library not have that you think forces you to write boilerplate?
- lifthrasiir 4y agoI believe Rust has the most conservative standard library among those modern languages and it still has many things that the C++ standard library simply don't have (yet): - Unified result types. C++23 is finally going to have `std::expected`, but it will probably take another version or two to see the `std::expected`-only version of standard library. - Iterator utilities. Again, C++23 will see a significant improvement in <ranges> but that still falls short of what Rust `Iterator` provides by default. - Checked arithmetic. Rust and many other languages distinguish checked and unchecked arithmetic and put one of them (typically unchecked one) into the standard library. C++ doesn't have anything like that. - Guarded mutex (that is, a portion of memory by design only accessible when locked) and concurrent queue. C++ does support concurrency out of the box, but its tools are pretty bare bones and this is one example.
- astrange 4y agoC++ doesn't have a module system, so you either have to declare everything twice, or put all your code in header files, or both.
- interpol_p 4y agoI don't write C++ much anymore, but to take an example where we want to union two sets (I'm sure the C++ one could be better? I've adapted from multiple examples) C++: int first[] = {1,2,3,4}; int second[] = {5,6,3,4}; std::vector<int> v(8); std::vector<int>::iterator it; std::sort (first,first + 4); // 1 2 3 4 std::sort (second,second + 4); // 3 4 5 6 it = std::set_union (first, first + 4, second, second + 4, v.begin()); v.resize(it - v.begin()); for(it = v.begin(); it != v.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; Swift: let a = Set([1,2,3,4]) let b = Set([5,6,3,4]) let c = a.union(b) print(c) //prints "[1, 2, 3, 5, 6, 4]"
- gpderetta 4y agostd::set a{1,2,3}; std::set b{5,6,3,4}; std::set c{a}; c.insert(b.begin, b.end()); for(auto x: c) std::cout<<c<<' c; std::cout << '\n';
- nly 4y agoIn C++20 the full program, retaining the same algorithm, can look like this: #include <algorithm> #include <iterator> #include <vector> #include <iostream> using namespace std::ranges; int main() { std::vector a = {1,2,3,4}; std::vector b = {5,6,3,4}; sort(a); sort(b); decltype(a) c; set_union (a, b, back_inserter(c)); copy(c, std::ostream_iterator<int>(std::cout, "\n")); } https://gcc.godbolt.org/z/44Ksf1hK8 https://gcc.godbolt.org/z/44Ksf1hK8 Note the value type deduction when declaring the vectors, the use of back_inserter to avoid having to resize the result (c) vector, the use of std::ranges to do away with all the begin + end crapola, and the way ranges and iterators are inter-mixed. C++ is always going to be a bit more verbose in trivial cases, but it's not that bad, and exposes a lot more flexibility in complex ones.
- interpol_p 4y agoThanks for the modernised version! It looks a lot better
- ChubbyGlasses 4y agoI think there are different ways to look at boilerplate, some of which languages like C++ and Rust are great at handling through their standard libraries, but there is also code boilerplate that needs language support handle well. defer and C-style for loops being the most well known constructs where the language provides syntax for something that otherwise would be difficult to express with just functions and lifetimes. Swift goes a step beyond by providing syntax for many other common patterns (aka boilerplate). For example, a few areas where Swift reduces boilerplate and the syntax it provides to do so: - a complete null/optional story: first class optional types (T? = Option<T>), null chaining (obj?.prop), and null coalescing (T ?? "default") - error handling: fn() throws Err (= fn() -> Result<T,Err>), try, try?, try!, do/catch (out-of-band error handling), w/o stack unwinding, see nulls - and struct/enum lifecycle management: constructors, getter/setter props, defaults, named functions, named tuples, etc. (this list is loong) Individually each feature is small and could possibly be argued as bloat or overhead since you can accomplish the same with just regular functions and Rust-like code and abstractions, but combined they make the language feel more expressive (and more fun IMO) than would otherwise be possible and often without sacrificing performance. They also serve to reduce cognitive overhead in the same way using for loops is nicer than desugaring to while loops. This is nothing to say of the syntax itself, and a bunch of other small features; Swift really is a case where the whole is greater than the sum of of its parts.