
PatternFly – a web UI framework by RedHat - 1023bytes
https://www.patternfly.org/
======
ggreer
I work at Red Hat (part of the CoreOS acquisition) and I have to say that
PatternFly has not been useful to the project I work on.[1]

First, PatternFly is big. We were mandated to adopt it, and it tripled our CSS
(from 45kB to 145kB). PatternFly also bundles Open Sans web fonts, which
(depending on font format) add another 200kB to 4MB to the initial page
load.[2]

Second, development is slow. There's a rewrite of PatternFly in the works, and
its roadmap predicts a 1.0 release after April of 2019.[3] It's a CSS
framework! How can it take over a year to make?! There will be two major
releases of React in the same time.

Speaking of React... PatternFly-React has similar shortcomings. Their babel
setup doesn't seem to support tree shaking, so if you use any PF-React
component you'll have to bundle 2MB of JS. The speed and quality of
development leaves much to be desired. For example: It took them five months
to merge a TTY component.[4] We wrote a similar component in two days.[5]

1\.
[https://github.com/openshift/console](https://github.com/openshift/console)

2\.
[https://github.com/openshift/console/pull/3](https://github.com/openshift/console/pull/3)

3\. [https://github.com/patternfly/patternfly-
next/milestones?dir...](https://github.com/patternfly/patternfly-
next/milestones?direction=asc&sort=title)

4\. [https://github.com/patternfly/patternfly-
react/pull/160](https://github.com/patternfly/patternfly-react/pull/160)

5\.
[https://github.com/openshift/console/pull/34](https://github.com/openshift/console/pull/34)

~~~
underwater
Why would you shit all over your colleagues’ work like that? An announcement
post is not a place to air your grievances.

I don’t even understand why you’d compare a pattern library to a rendering
framework. And comparing development speed for a component in a shared library
against that for a single use case is completely unfair.

~~~
ggreer
> Why would you shit all over your colleagues’ work like that? An announcement
> post is not a place to air your grievances.

I know it's unkind to air dirty laundry, but there are no good options. Either
I'm disloyal to some of my coworkers, or I let a bunch of developers to run
into the same problems I did.

If the positions were reversed and I was considering a library, I'd want
employees to chime in with their experience using it. That remains true even
if those experiences were negative.

~~~
pknopf
> I know it's unkind to air dirty laundry

The term "dirty laundry" implies personal issues or just politics. Your
assessment seemed rational and centered around the product itself.

I'm not sure why you got that kind of reaction from OP.

------
thefuzzy
I've tried to use PatteryFly a few times, it's actually a pretty terrible
system. the biggest drawback is the lack of documentation...as you click
through what they call documentation it's full of missing content and 404's.
Personally, it's just better to use adminLTE or Twitter Bootstrap.

With the exception of RHEL, it's just like most of Red Hat's
products...purchased from someone else, half-baked, and a rather pathetic
attempt to stay relevant. It seems that the only support is from internal RH
devs and if you look at a lot of Red Hat's other products, even they can't
really figure out how to use it (see ManageIQ).

~~~
lima
> It seems that the only support is from internal RH devs

That's because it's an internal RH framework. Red Hat happens to open source
most of their stuff, so they put some effort into marketing PatternFly, but
it's still mostly used by themselves.

That being said, the people on their Slack channel are extremely helpful!

------
est
If you are into bootstrap, [https://bulma.io/](https://bulma.io/) is also
worth checkout

~~~
thestepafter
I highly recommend TailwindCSS as well. Spend an hour with it and you will see
significant improvements to the time it takes writing HTML and CSS.

~~~
pknopf
Wow, that is an interesting approach they got there.

The Bootstrap/Foundation abstractions are rarely "just right", always
requiring you to change/fork/deviate from the norm. I like the idea of
building the abstractions myself, exactly as I need them.

Thanks for sharing!

------
aphextron
The problem with all these frameworks is you end up with a huge mess of markup
unrelated to your application, and then have to have another tab open the
entire time with documentation making sure you spell every class name right
and dont miss a single <div> tag.

Native web components with shadow DOM styling are the way to go forward IMO.
Otherwise stuff like this leads to namespace issues and horrible regressions
caused when the inevitable need to override something occurs and your only
option is to !important a property.

~~~
coldtea
> _Native web components with shadow DOM styling are the way to go forward
> IMO_

Frameworks like React and Angular are 10x more popular than "native web
components".

So if "having to have another tab open the entire time with documentation
making sure you spell every class name right and dont miss a single <div> tag"
is your concern, it's misplaced. People will be more familiar with those
others than with native web components.

------
eropple
I've never seen this before, but it looks kind of neat. Right now I use
Material UI for React stuff, and it works well enough, but I picked it mostly
because I think its API is cleaner than the other frameworks I've worked with.
I see that PatternFly has a React library; can anyone speak to how it is to
use?

------
rwmj
I've had PatternFly on my to-do list to investigate a bit more for a while.
However I'm at a loss, after reading the website, to understand what it is. Is
it a set of styles? Design guidelines? Code for widgets?

 _(Disclaimer: I work for Red Hat, but doing low-level stuff)_

~~~
drivingmenuts
At it's core, it's apparently just Bootstrap, an HTML/CSS/JS library. The
React version is a whole JS front-end framework.

I'd rather it was built around Bootstrap 4, but I didn't write it, can't be
too choosy.

------
solarkraft
What has caused the sudden spike of Web UI frameworks?

~~~
ttul
RedHat lives and dies on value to the enterprise. Their consultants need to
find a way to stop enterprise customers from just reaching for whatever FOSS
is out there. By giving away their own framework, they can keep their clients
in the redhat universe where redhat folks have expertise to offer.

~~~
jacques_chester
I don't think this is true at all. Red Hat needed a web toolkit for their
products and presumably decided that the available options weren't suitable
for their purposes.

These are more common now because a few years ago a lot of folks drew the same
conclusions at around the same time.

For example, PivotalUI[0] was developed in-house to provide a uniform toolkit
and look-n-feel for Pivotal's various web interfaces (Pivotal Network, OpsMan,
AppsMan, Healthcheck, Metrics etc). Other examples include JetBrains's
RingUI[1] or Microsoft's ReactXP[2].

But by no means is PivotalUI intended to lock anyone into anything. To my
knowledge our consulting division, Pivotal Labs, has undertaken approximately
zero projects using Pivotal UI.

Disclosure: I work for Pivotal. We compete with Red Hat.

[0] [https://styleguide.pivotal.io/](https://styleguide.pivotal.io/)

[1] [https://www.jetbrains.org/ring-
ui/index.html](https://www.jetbrains.org/ring-ui/index.html)

[2]
[https://microsoft.github.io/reactxp/](https://microsoft.github.io/reactxp/)

~~~
AlphaSite
VMware has something similar in clarity[0], and I guess they decided that
bootstrap in a mobile first framework and what they wanted was desktop first,
since that what their customers use. I guess what matters more than reactive
are wizards, login screens and tables[1]. Incidentally whoever made these
examples appears to love pokemon.

[0] [https://github.com/vmware/clarity](https://github.com/vmware/clarity)

[1] [https://imgur.com/a/5j4PaIR](https://imgur.com/a/5j4PaIR)

------
Annatar
redhat finally went where it truly belongs since decades ago: web rather than
OS implementation.

Now, if they would so kind as to exit OS design and implementation, stage
right, that would be awesome. The faster the better.

~~~
prlin
What’s wrong with Redhat Linux?

~~~
Annatar
redhat couldn't _engineer_ an operating system to save their life: systemd is
a Windows-like system, they constantly break backwards compatibility, their
compiler is purposely castrated to only produce 64-bit code, memory overcommit
is still a thing and ships out of the box turned on, they can't get NFS to
work correctly and haven't been able to for decades, they can't get
fiberchannel to work correctly, they resisted and sabotaged XFS for decades
only to now make it a default after having made their customers to suffer with
ext2, 3, and 4 for twenty years, they resist ZFS, they've allowed netstat to
be deprecated in favor of ss, both GFS and GFS 2 are disasters which they
could never get to work correctly, Puppet is a disaster, Saltstack is a
disaster, Cobbler is a disaster, Satellite / Spacewalk is a disaster...
seriously, what _can_ redhat do correctly?

They spend more time arguing with paying customers on bugzilla.redhat.com than
fixing their code because it's easier to argue than to find out where the
problem is, or to solve the problem properly.

~~~
nailer
Red Hat break backwards compatibility every 10 years. the LTS approach has
been copied by every other Linux distro.

systemd is windows-like in that it replaces a seperate and duplicate code in
init, cron, atd, forever, and a billion init scripts with something actually
designed.

Red Hat has supported XFS and paid it's maintainers for something like 15
years now.

I could discuss the rest but it honestly seems you're arguing from an
emotional viewpoint rather than a technical one.

~~~
Annatar
I'm merely answering the "what's wrong with Redhat Linux?" question: it's
enough to go to bugzilla.redhat.com and pull the publicly open priority 1
critical bugs, read the exchange between users and redhat and a pattern
emerges. Never mind what I wrote and what I suffer through on RHEL every day,
let's ignore and discount that; it's the exchanges in the priority 1 bugs that
tell the tale for themselves far better than I ever could.

Try building RPM's between .el5, .el6 and .el7, the macro definitions are
ripped out and (partially) put back in or modified for more often than every
ten years. And that's just one example of many. Starting with .el6 they made
their RPM backend scripts bust if -Wl,--build-id isn't used in CXXFLAGS,
CFLAGS, and FFLAGS because they modified their castrated compiler to encode
that automatically and rely on it instead, so if you roll your own fixed
version of the compiler but don't implement that, all your RPM builds are
suddenly broken. Now I have to put that work-around in my compilers. Should I
go on? I've got plenty of technical details...

So yeah, they should go into web and not touch OS and kernel engineering ever
again.

~~~
lima
Looking at prio 1 bugs for a huge distro like RHEL is not going to paint an
accurate picture.

I've had production experience with all the major distros except SUSE, and Red
Hat's QA is miles ahead anyone else's. Canonical/Ubuntu do a particularly bad
job at it, for instance.

That's not to say there aren't any issues with it, and I've personally
experienced a few (the devicemapper Docker driver, for example, caused a lot
of trouble for me and I'm glad they did the right thing and built overlayfs),
but overall, their engineering is very solid.

~~~
Annatar
You've never used a traditional UNIX if you think redhat's engineering is
solid, have you?

~~~
lima
> _There exist no words in any of the languages I speak which can express my
> hate of GNU and GNU /Linux._

We might not find much common ground there :-)

I'll bite: I worked with a bunch of HP-UX systems before they got
decommissioned a few years ago, so I can attest both to how well-built the
operating system is, as well as how painful it was to get anything modern
running on them. I also keep an eye on SmartOS/SmartDataCenter.

However, how does this make Red Hat's engineering bad?

~~~
Annatar
HP-UX was hard to get started on building software, but once one builds up a
base of common libraries, it gets easier and easier, just like it did on
Solaris.

hp's engineers never broke backward compatibility. The OS is lightning fast
and rock solid. That takes a lot of insight and knowledge.

redhat constantly brakes things, I find things which work yetsterday that
break tody, even in the same mainline release. They couldn't even get shutdown
to work correctly, a couple of years back when we were working on integrating
XFS (and they were still resisting it), the kernel was panicking because they
were trying to write to an unmounted filesystem; that was 18 years into
Linux's development.

SmartOS engineers would never do such a thing on purpose, as they are guided
by the 'empathy is still a core engineering value', put in words in an answer
by Keith Wesolowski, and in those very rare cases when they do, they fix it
immediately.

With redhat we get constant finger pointing between them and the hardware
vendor, they never act responsible for anything although we pay them lots of
money. What the hell are we paying them for then? They can't even engineer
proper code and drivers for their own OS for the hardware they officially
support. That's not engineering, that's hacking!

The worst by far is their lack of architecture. Take Satellite for example,
with their concept of channels: unbelievably confusing and complicated. Have
you tried integrating your own RPM's into it? The needless complexity!

We had Satellite filling up an Oracle tablespace with irrelevant garbage log
information even though we just installed it; I called redhat up and asked
them how to lower the amount of information Satellite is generating so that it
wouldn't constantly fill up the tablespace. Their support told me that I have
to go talk to Oracle because it's an Oracle database problem! Yeah, they are
that kind of experts!

~~~
nailer
Solaris had XML config files and wouldn't boot if you had a tab character in
vfstab.

~~~
Annatar
Only SMF uses XML and SQLite behind the scenes. While that is a poor choice of
configuration format, SMF is considered the Golden standard which all others
try to re-invent and re-implement (not invented here syndrome), because SMF
has been working reliably for more than a decade, and all added capability
doesn’t break backwards compatibility, so an SMF manifest you wrote ten years
ago works without modifications on the latest and greatest nightly build of
illumos. That’s system engineering as opposed to haphazard hacking. I use
drivers in the latest illumos from 1995 and they run without recompilation or
modification. I’d like to see GNU/Linux pull that one off.

As for \t not working in vfstab(4), it’s simply not true, as all my vfstab(4)
files use the [TAB] characters to line up the fields.

~~~
nailer
Yeah they fixed the vfstab problem. It would have bitten you to if you used
Solaris back when it mattered.

~~~
Annatar
I’ve been using Solaris since 1993.

I still use it today.

~~~
nailer
Great. You weren't tab-indenting (or space-indenting, I can't remember which
one wrecked your machine) your vfstab back on Solaris 8.

~~~
Annatar
I most certainly was tab-indenting, since Solaris 2.5.1 in 1993.

